claude-coach 0.0.1

package/dist/viewer/lib/export/erg.js

@@ -0,0 +1,206 @@
+/**
+ * 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.
+ */
+/**
+ * Check if a sport is supported by ERG/MRC export
+ * Only cycling workouts make sense for trainer files
+ */
+export function isErgSupported(sport) {
+    return sport === "bike";
+}
+/**
+ * Convert intensity to percentage of FTP
+ */
+function intensityToPercent(intensity) {
+    // Intensity is stored as percentage (e.g., 75 for 75%)
+    return intensity;
+}
+/**
+ * Generate data points from structured workout
+ * Returns array of [minutes, percent] tuples
+ */
+function generateDataPoints(structure) {
+    const points = [];
+    let currentMinute = 0;
+    const addStep = (step) => {
+        const percent = intensityToPercent(step.intensity.value);
+        const durationMinutes = getDurationMinutes(step);
+        // Add start point
+        points.push([currentMinute, percent]);
+        // For ramps, add intermediate points
+        if (step.intensity.valueLow !== undefined && step.intensity.valueHigh !== undefined) {
+            const startPercent = intensityToPercent(step.intensity.valueLow);
+            const endPercent = intensityToPercent(step.intensity.valueHigh);
+            points[points.length - 1] = [currentMinute, startPercent];
+            currentMinute += durationMinutes;
+            points.push([currentMinute, endPercent]);
+        }
+        else {
+            currentMinute += durationMinutes;
+            // Add end point at same intensity (creates flat segment)
+            points.push([currentMinute, percent]);
+        }
+    };
+    const getDurationMinutes = (step) => {
+        switch (step.duration.unit) {
+            case "seconds":
+                return step.duration.value / 60;
+            case "minutes":
+                return step.duration.value;
+            case "hours":
+                return step.duration.value * 60;
+            default:
+                // For distance-based, estimate ~30km/h average
+                if (step.duration.unit === "meters") {
+                    return (step.duration.value / 1000 / 30) * 60;
+                }
+                if (step.duration.unit === "kilometers") {
+                    return (step.duration.value / 30) * 60;
+                }
+                return step.duration.value;
+        }
+    };
+    // Process warmup
+    if (structure.warmup) {
+        for (const step of structure.warmup) {
+            addStep(step);
+        }
+    }
+    // Process main set
+    for (const item of structure.main) {
+        if ("repeats" in item) {
+            const intervalSet = item;
+            for (let i = 0; i < intervalSet.repeats; i++) {
+                for (const step of intervalSet.steps) {
+                    addStep(step);
+                }
+            }
+        }
+        else {
+            addStep(item);
+        }
+    }
+    // Process cooldown
+    if (structure.cooldown) {
+        for (const step of structure.cooldown) {
+            addStep(step);
+        }
+    }
+    return points;
+}
+/**
+ * Generate simple data points when no structure is provided
+ */
+function generateSimpleDataPoints(workout) {
+    const totalMinutes = workout.durationMinutes || 60;
+    const points = [];
+    // Determine main intensity based on workout type
+    let mainPercent = 65;
+    switch (workout.type) {
+        case "recovery":
+            mainPercent = 55;
+            break;
+        case "endurance":
+            mainPercent = 65;
+            break;
+        case "tempo":
+            mainPercent = 80;
+            break;
+        case "threshold":
+            mainPercent = 95;
+            break;
+        case "vo2max":
+            mainPercent = 110;
+            break;
+        case "intervals":
+            mainPercent = 85;
+            break;
+    }
+    // Warmup (10% of total, ramp from 40% to 65%)
+    const warmupMinutes = Math.min(15, Math.max(5, Math.round(totalMinutes * 0.1)));
+    points.push([0, 40]);
+    points.push([warmupMinutes, 65]);
+    // Main set
+    const cooldownMinutes = Math.min(10, Math.max(5, Math.round(totalMinutes * 0.1)));
+    const mainMinutes = totalMinutes - warmupMinutes - cooldownMinutes;
+    points.push([warmupMinutes, mainPercent]);
+    points.push([warmupMinutes + mainMinutes, mainPercent]);
+    // Cooldown (ramp from 60% to 40%)
+    points.push([warmupMinutes + mainMinutes, 60]);
+    points.push([totalMinutes, 40]);
+    return points;
+}
+/**
+ * Generate a complete MRC file for a workout
+ */
+export function generateMrc(workout, _settings) {
+    if (!isErgSupported(workout.sport)) {
+        throw new Error(`ERG/MRC export only supports bike workouts`);
+    }
+    const dataPoints = workout.structure
+        ? generateDataPoints(workout.structure)
+        : generateSimpleDataPoints(workout);
+    // Build description from workout info
+    let description = workout.name;
+    if (workout.description) {
+        description += ` - ${workout.description}`;
+    }
+    const lines = [
+        "[COURSE HEADER]",
+        `VERSION = 2`,
+        `UNITS = ENGLISH`,
+        `DESCRIPTION = ${description.replace(/[\r\n]/g, " ")}`,
+        `FILE NAME = ${workout.name}`,
+        `MINUTES PERCENT`,
+        "[END COURSE HEADER]",
+        "[COURSE DATA]",
+    ];
+    // Add data points
+    for (const [minutes, percent] of dataPoints) {
+        lines.push(`${minutes.toFixed(2)}\t${percent.toFixed(0)}`);
+    }
+    lines.push("[END COURSE DATA]");
+    return lines.join("\n");
+}
+/**
+ * Generate ERG file (absolute watts) - requires FTP
+ */
+export function generateErg(workout, settings) {
+    if (!isErgSupported(workout.sport)) {
+        throw new Error(`ERG/MRC export only supports bike workouts`);
+    }
+    const ftp = settings.bike?.ftp || 200; // Default to 200W if not set
+    const dataPoints = workout.structure
+        ? generateDataPoints(workout.structure)
+        : generateSimpleDataPoints(workout);
+    let description = workout.name;
+    if (workout.description) {
+        description += ` - ${workout.description}`;
+    }
+    const lines = [
+        "[COURSE HEADER]",
+        `VERSION = 2`,
+        `UNITS = ENGLISH`,
+        `DESCRIPTION = ${description.replace(/[\r\n]/g, " ")}`,
+        `FILE NAME = ${workout.name}`,
+        `FTP = ${ftp}`,
+        `MINUTES WATTS`,
+        "[END COURSE HEADER]",
+        "[COURSE DATA]",
+    ];
+    // Add data points converted to watts
+    for (const [minutes, percent] of dataPoints) {
+        const watts = Math.round((percent / 100) * ftp);
+        lines.push(`${minutes.toFixed(2)}\t${watts}`);
+    }
+    lines.push("[END COURSE DATA]");
+    return lines.join("\n");
+}

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

@@ -0,0 +1,25 @@
+/**
+ * FIT (Garmin) Workout Export
+ *
+ * Generates Garmin FIT workout files that can be uploaded to Garmin Connect.
+ * Uses the official @garmin/fitsdk package for binary FIT encoding.
+ *
+ * How to import to Garmin:
+ * - Upload to Garmin Connect (connect.garmin.com) -> Training -> Workouts -> Import
+ * - The workout will sync to compatible Garmin devices
+ */
+import type { Workout, Sport } from "../../../schema/training-plan.js";
+import type { Settings } from "../../stores/settings.js";
+/**
+ * Check if the FIT SDK is available at runtime
+ * Always returns true since the SDK is now bundled
+ */
+export declare function isFitSdkAvailable(): Promise<boolean>;
+/**
+ * Check if a sport is supported by FIT export
+ */
+export declare function isFitSupported(sport: Sport): boolean;
+/**
+ * Generate a complete FIT workout file
+ */
+export declare function generateFit(workout: Workout, _settings: Settings): Promise<Uint8Array>;

package/dist/viewer/lib/export/fit.js

@@ -0,0 +1,307 @@
+/**
+ * FIT (Garmin) Workout Export
+ *
+ * Generates Garmin FIT workout files that can be uploaded to Garmin Connect.
+ * Uses the official @garmin/fitsdk package for binary FIT encoding.
+ *
+ * How to import to Garmin:
+ * - Upload to Garmin Connect (connect.garmin.com) -> Training -> Workouts -> Import
+ * - The workout will sync to compatible Garmin devices
+ */
+import { Encoder, Profile } from "@garmin/fitsdk";
+/**
+ * Check if the FIT SDK is available at runtime
+ * Always returns true since the SDK is now bundled
+ */
+export async function isFitSdkAvailable() {
+    return true;
+}
+/**
+ * Check if a sport is supported by FIT export
+ */
+export function isFitSupported(sport) {
+    // FIT supports most sports, excluding rest and race-specific
+    return sport !== "rest" && sport !== "race";
+}
+/**
+ * Map our sport types to FIT sport enum values
+ */
+function getFitSport(sport) {
+    switch (sport) {
+        case "swim":
+            return "swimming";
+        case "bike":
+            return "cycling";
+        case "run":
+            return "running";
+        case "strength":
+            return "training";
+        case "brick":
+            return "multisport";
+        default:
+            return "generic";
+    }
+}
+/**
+ * Map our sport types to FIT sub_sport enum values
+ */
+function getFitSubSport(sport) {
+    switch (sport) {
+        case "swim":
+            return "lap_swimming";
+        case "bike":
+            return "road";
+        case "run":
+            return "road";
+        case "strength":
+            return "strength_training";
+        case "brick":
+            return "triathlon";
+        default:
+            return "generic";
+    }
+}
+/**
+ * Get workout step intensity/duration type based on step type
+ */
+function getStepIntensity(stepType) {
+    switch (stepType) {
+        case "warmup":
+            return "warmup";
+        case "cooldown":
+            return "cooldown";
+        case "rest":
+            return "rest";
+        case "recovery":
+            return "recovery";
+        case "work":
+            return "active";
+        default:
+            return "active";
+    }
+}
+/**
+ * Convert duration to FIT workout step duration
+ */
+function getDurationValue(value, unit) {
+    switch (unit) {
+        case "seconds":
+            return value * 1000; // FIT uses milliseconds
+        case "minutes":
+            return value * 60 * 1000;
+        case "hours":
+            return value * 3600 * 1000;
+        case "meters":
+            return value * 100; // FIT uses centimeters
+        case "kilometers":
+            return value * 100000;
+        case "miles":
+            return value * 160934; // cm per mile
+        default:
+            return value * 1000;
+    }
+}
+/**
+ * Get duration type for FIT
+ */
+function getDurationType(unit) {
+    switch (unit) {
+        case "seconds":
+        case "minutes":
+        case "hours":
+            return "time";
+        case "meters":
+        case "kilometers":
+        case "miles":
+            return "distance";
+        default:
+            return "time";
+    }
+}
+/**
+ * Generate workout steps from structured workout
+ */
+function generateStepsFromStructure(structure) {
+    const steps = [];
+    let stepIndex = 0;
+    // Helper to add a step
+    const addStep = (step, isPartOfRepeat = false) => {
+        const durationType = getDurationType(step.duration.unit);
+        const durationValue = getDurationValue(step.duration.value, step.duration.unit);
+        const fitStep = {
+            messageIndex: stepIndex,
+            workoutStepName: step.name || "",
+            intensity: getStepIntensity(step.type),
+            durationType: durationType,
+            durationValue: durationValue,
+            notes: step.notes || "",
+        };
+        // Add target based on intensity unit
+        if (step.intensity) {
+            switch (step.intensity.unit) {
+                case "percent_ftp":
+                    fitStep.targetType = "power";
+                    fitStep.targetValue = 0;
+                    fitStep.customTargetValueLow = step.intensity.valueLow || step.intensity.value - 5;
+                    fitStep.customTargetValueHigh = step.intensity.valueHigh || step.intensity.value + 5;
+                    break;
+                case "percent_lthr":
+                case "hr_zone":
+                    fitStep.targetType = "heart_rate";
+                    fitStep.targetValue = 0;
+                    // HR zone values need to be actual BPM if available
+                    if (step.intensity.valueLow !== undefined && step.intensity.valueHigh !== undefined) {
+                        fitStep.customTargetValueLow = step.intensity.valueLow;
+                        fitStep.customTargetValueHigh = step.intensity.valueHigh;
+                    }
+                    else {
+                        // Use zone as target value (1-5)
+                        fitStep.targetValue = step.intensity.value;
+                    }
+                    break;
+                case "rpe":
+                    // No direct RPE support in FIT, use open target
+                    fitStep.targetType = "open";
+                    break;
+                default:
+                    fitStep.targetType = "open";
+            }
+        }
+        else {
+            fitStep.targetType = "open";
+        }
+        // Add cadence target if present
+        if (step.cadence) {
+            fitStep.customTargetCadenceLow = step.cadence.low;
+            fitStep.customTargetCadenceHigh = step.cadence.high;
+        }
+        steps.push(fitStep);
+        stepIndex++;
+        return stepIndex - 1;
+    };
+    // Helper to add interval set
+    const addIntervalSet = (intervalSet) => {
+        // For FIT, we need to add a repeat step that references the child steps
+        const repeatStepIndex = stepIndex;
+        stepIndex++; // Reserve index for repeat step
+        // Add the child steps
+        const childStepIndices = [];
+        for (const childStep of intervalSet.steps) {
+            childStepIndices.push(addStep(childStep, true));
+        }
+        // Create the repeat step
+        const repeatStep = {
+            messageIndex: repeatStepIndex,
+            workoutStepName: intervalSet.name || "Intervals",
+            durationType: "repeat_until_steps_cmplt",
+            durationValue: intervalSet.repeats,
+            targetType: "open",
+            intensity: "interval",
+        };
+        // Insert repeat step at correct position
+        steps.splice(repeatStepIndex, 0, repeatStep);
+        stepIndex++; // Adjust for inserted repeat step
+    };
+    // Process warmup
+    if (structure.warmup) {
+        for (const step of structure.warmup) {
+            addStep(step);
+        }
+    }
+    // Process main set
+    for (const item of structure.main) {
+        if ("repeats" in item) {
+            addIntervalSet(item);
+        }
+        else {
+            addStep(item);
+        }
+    }
+    // Process cooldown
+    if (structure.cooldown) {
+        for (const step of structure.cooldown) {
+            addStep(step);
+        }
+    }
+    return { steps, totalSteps: steps.length };
+}
+/**
+ * Generate simple workout steps when no structure is provided
+ */
+function generateSimpleSteps(workout) {
+    const steps = [];
+    const totalMinutes = workout.durationMinutes || 60;
+    // Warmup (10% of total, 5-15 min)
+    const warmupMinutes = Math.min(15, Math.max(5, Math.round(totalMinutes * 0.1)));
+    steps.push({
+        messageIndex: 0,
+        workoutStepName: "Warm Up",
+        intensity: "warmup",
+        durationType: "time",
+        durationValue: warmupMinutes * 60 * 1000,
+        targetType: "open",
+    });
+    // Main (80% of total)
+    const cooldownMinutes = Math.min(10, Math.max(5, Math.round(totalMinutes * 0.1)));
+    const mainMinutes = totalMinutes - warmupMinutes - cooldownMinutes;
+    let mainIntensity = "active";
+    if (workout.type === "recovery")
+        mainIntensity = "recovery";
+    else if (workout.type === "rest")
+        mainIntensity = "rest";
+    else if (workout.type === "intervals" || workout.type === "vo2max")
+        mainIntensity = "interval";
+    steps.push({
+        messageIndex: 1,
+        workoutStepName: "Main Set",
+        intensity: mainIntensity,
+        durationType: "time",
+        durationValue: mainMinutes * 60 * 1000,
+        targetType: "open",
+        notes: workout.description || "",
+    });
+    // Cooldown (10% of total, 5-10 min)
+    steps.push({
+        messageIndex: 2,
+        workoutStepName: "Cool Down",
+        intensity: "cooldown",
+        durationType: "time",
+        durationValue: cooldownMinutes * 60 * 1000,
+        targetType: "open",
+    });
+    return { steps, totalSteps: 3 };
+}
+/**
+ * Generate a complete FIT workout file
+ */
+export async function generateFit(workout, _settings) {
+    if (!isFitSupported(workout.sport)) {
+        throw new Error(`FIT export not supported for ${workout.sport} workouts`);
+    }
+    const encoder = new Encoder();
+    // File ID message (required)
+    encoder.onMesg(Profile.MesgNum.FILE_ID, {
+        type: "workout",
+        manufacturer: "development",
+        product: 1,
+        serialNumber: Math.floor(Math.random() * 1000000),
+        timeCreated: new Date(),
+    });
+    // Generate steps
+    const { steps, totalSteps } = workout.structure
+        ? generateStepsFromStructure(workout.structure)
+        : generateSimpleSteps(workout);
+    // Workout message
+    encoder.onMesg(Profile.MesgNum.WORKOUT, {
+        workoutName: workout.name,
+        sport: getFitSport(workout.sport),
+        subSport: getFitSubSport(workout.sport),
+        numValidSteps: totalSteps,
+    });
+    // Write workout steps
+    for (const step of steps) {
+        encoder.onMesg(Profile.MesgNum.WORKOUT_STEP, step);
+    }
+    // Finalize and return
+    return encoder.close();
+}

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

@@ -0,0 +1,13 @@
+/**
+ * ICS (iCalendar) Export
+ *
+ * Generates iCalendar files (RFC 5545) for importing training plans
+ * into Google Calendar, Apple Calendar, Outlook, etc.
+ *
+ * Each workout becomes an all-day event on its scheduled date.
+ */
+import type { TrainingPlan } from "../../../schema/training-plan.js";
+/**
+ * Generate a complete iCalendar file for the training plan
+ */
+export declare function generateIcs(plan: TrainingPlan): string;

package/dist/viewer/lib/export/ics.js

@@ -0,0 +1,138 @@
+/**
+ * ICS (iCalendar) Export
+ *
+ * Generates iCalendar files (RFC 5545) for importing training plans
+ * into Google Calendar, Apple Calendar, Outlook, etc.
+ *
+ * Each workout becomes an all-day event on its scheduled date.
+ */
+import { formatDuration, getSportIcon } from "../utils.js";
+/**
+ * Format date as iCalendar DATE value (YYYYMMDD)
+ */
+function formatIcsDate(dateStr) {
+    return dateStr.replace(/-/g, "");
+}
+/**
+ * Escape special characters for iCalendar text fields
+ * According to RFC 5545, we need to escape: backslash, semicolon, comma, newline
+ */
+function escapeIcsText(text) {
+    return text
+        .replace(/\\/g, "\\\\") // Backslash
+        .replace(/;/g, "\\;") // Semicolon
+        .replace(/,/g, "\\,") // Comma
+        .replace(/\n/g, "\\n") // Newline
+        .replace(/\\n/g, "\\n"); // Handle already-escaped newlines from humanReadable
+}
+/**
+ * Fold long lines according to RFC 5545 (max 75 octets per line)
+ */
+function foldLine(line) {
+    const maxLength = 75;
+    if (line.length <= maxLength) {
+        return line;
+    }
+    const result = [];
+    let remaining = line;
+    // First line can be full length
+    result.push(remaining.substring(0, maxLength));
+    remaining = remaining.substring(maxLength);
+    // Continuation lines start with space and have length 74 (75 - 1 for space)
+    while (remaining.length > 0) {
+        result.push(" " + remaining.substring(0, 74));
+        remaining = remaining.substring(74);
+    }
+    return result.join("\r\n");
+}
+/**
+ * Generate a unique identifier for an event
+ */
+function generateUid(workoutId, date) {
+    return `${workoutId}-${date}@claude-coach`;
+}
+/**
+ * Generate a VEVENT for a workout
+ */
+function generateVevent(workout, day, planName) {
+    const uid = generateUid(workout.id, day.date);
+    const dateStr = formatIcsDate(day.date);
+    const sportEmoji = getSportIcon(workout.sport);
+    const duration = formatDuration(workout.durationMinutes);
+    // Summary: emoji + sport type + workout name
+    const summary = escapeIcsText(`${sportEmoji} ${workout.sport.charAt(0).toUpperCase() + workout.sport.slice(1)}: ${workout.name}`);
+    // Description: include all workout details
+    let description = "";
+    if (workout.description) {
+        description += workout.description + "\\n\\n";
+    }
+    if (duration) {
+        description += `Duration: ${duration}\\n`;
+    }
+    if (workout.primaryZone) {
+        description += `Target Zone: ${workout.primaryZone}\\n`;
+    }
+    if (workout.humanReadable) {
+        description += "\\nWorkout Structure:\\n" + workout.humanReadable.replace(/\\n/g, "\\n");
+    }
+    description = escapeIcsText(description.trim());
+    // Categories for filtering
+    const categories = [workout.sport, workout.type, planName].join(",");
+    const lines = [
+        "BEGIN:VEVENT",
+        foldLine(`UID:${uid}`),
+        `DTSTAMP:${new Date().toISOString().replace(/[-:]/g, "").split(".")[0]}Z`,
+        `DTSTART;VALUE=DATE:${dateStr}`,
+        `DTEND;VALUE=DATE:${dateStr}`, // All-day event
+        foldLine(`SUMMARY:${summary}`),
+        foldLine(`DESCRIPTION:${description}`),
+        foldLine(`CATEGORIES:${escapeIcsText(categories)}`),
+        `TRANSP:TRANSPARENT`, // Don't block time (shows as free)
+        "END:VEVENT",
+    ];
+    return lines.join("\r\n");
+}
+/**
+ * Generate a complete iCalendar file for the training plan
+ */
+export function generateIcs(plan) {
+    const now = new Date().toISOString().replace(/[-:]/g, "").split(".")[0] + "Z";
+    const header = [
+        "BEGIN:VCALENDAR",
+        "VERSION:2.0",
+        "PRODID:-//Claude Coach//Training Plan//EN",
+        "CALSCALE:GREGORIAN",
+        "METHOD:PUBLISH",
+        `X-WR-CALNAME:${escapeIcsText(plan.meta.event)} Training`,
+        `X-WR-CALDESC:${escapeIcsText(`Training plan for ${plan.meta.event} on ${plan.meta.eventDate}`)}`,
+    ].join("\r\n");
+    const events = [];
+    // Generate events for all workouts
+    for (const week of plan.weeks) {
+        for (const day of week.days) {
+            for (const workout of day.workouts) {
+                // Skip rest days without actual workouts
+                if (workout.sport === "rest" && !workout.name) {
+                    continue;
+                }
+                events.push(generateVevent(workout, day, plan.meta.event));
+            }
+        }
+    }
+    // Add a race day event
+    const raceDayEvent = [
+        "BEGIN:VEVENT",
+        `UID:race-day@claude-coach`,
+        `DTSTAMP:${now}`,
+        `DTSTART;VALUE=DATE:${formatIcsDate(plan.meta.eventDate)}`,
+        `DTEND;VALUE=DATE:${formatIcsDate(plan.meta.eventDate)}`,
+        foldLine(`SUMMARY:\u{1F3C6} RACE DAY: ${escapeIcsText(plan.meta.event)}`),
+        foldLine(`DESCRIPTION:${escapeIcsText(`Race day for ${plan.meta.event}!`)}`),
+        `CATEGORIES:race,${escapeIcsText(plan.meta.event)}`,
+        `TRANSP:OPAQUE`, // Block time for race day
+        "END:VEVENT",
+    ].join("\r\n");
+    events.push(raceDayEvent);
+    const footer = "END:VCALENDAR";
+    return header + "\r\n" + events.join("\r\n") + "\r\n" + footer;
+}