claude-coach 0.0.1

package/dist/viewer/stores/changes.d.ts

@@ -0,0 +1,21 @@
+import type { Workout } from "../../schema/training-plan.js";
+/**
+ * Tracks all user modifications to the plan.
+ * These are stored as overlays on top of the original plan data.
+ */
+export interface PlanChanges {
+    moved: Record<string, string>;
+    edited: Record<string, Partial<Workout>>;
+    deleted: string[];
+    added: Record<string, {
+        date: string;
+        workout: Workout;
+    }>;
+}
+export declare function emptyChanges(): PlanChanges;
+export declare function loadChanges(): PlanChanges;
+export declare function saveChanges(changes: PlanChanges): void;
+export declare function generateWorkoutId(): string;
+export declare function getWorkoutDate(workoutId: string, originalDate: string, changes: PlanChanges): string;
+export declare function getEffectiveWorkout(workout: Workout, changes: PlanChanges): Workout;
+export declare function isWorkoutDeleted(workoutId: string, changes: PlanChanges): boolean;

package/dist/viewer/stores/changes.js

@@ -0,0 +1,49 @@
+import { planData } from "./plan.js";
+const storageKey = `plan-${planData.meta.id}-changes`;
+export function emptyChanges() {
+    return {
+        moved: {},
+        edited: {},
+        deleted: [],
+        added: {},
+    };
+}
+export function loadChanges() {
+    const saved = localStorage.getItem(storageKey);
+    if (!saved)
+        return emptyChanges();
+    try {
+        const parsed = JSON.parse(saved);
+        return {
+            moved: parsed.moved || {},
+            edited: parsed.edited || {},
+            deleted: parsed.deleted || [],
+            added: parsed.added || {},
+        };
+    }
+    catch {
+        return emptyChanges();
+    }
+}
+export function saveChanges(changes) {
+    localStorage.setItem(storageKey, JSON.stringify(changes));
+}
+// Helper to generate unique IDs for new workouts
+export function generateWorkoutId() {
+    return `user-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+// Get the effective date for a workout (considering moves)
+export function getWorkoutDate(workoutId, originalDate, changes) {
+    return changes.moved[workoutId] || originalDate;
+}
+// Get the effective workout data (considering edits)
+export function getEffectiveWorkout(workout, changes) {
+    const edits = changes.edited[workout.id];
+    if (!edits)
+        return workout;
+    return { ...workout, ...edits };
+}
+// Check if a workout is deleted
+export function isWorkoutDeleted(workoutId, changes) {
+    return changes.deleted.includes(workoutId);
+}

package/dist/viewer/stores/plan.d.ts

@@ -0,0 +1,4 @@
+import type { TrainingPlan } from "../../schema/training-plan.js";
+export declare const planData: TrainingPlan;
+export declare function loadCompleted(): Record<string, boolean>;
+export declare function saveCompleted(completed: Record<string, boolean>): void;

package/dist/viewer/stores/plan.js

@@ -0,0 +1,19 @@
+// Load plan from embedded JSON
+function loadPlanData() {
+    const el = document.getElementById("plan-data");
+    if (!el)
+        throw new Error("Plan data not found");
+    return JSON.parse(el.textContent || "{}");
+}
+// Reactive state using Svelte 5's $state rune is only available in .svelte files
+// So we export the raw data and let components create reactive state
+export const planData = loadPlanData();
+// Completed workouts stored in localStorage
+const storageKey = `plan-${planData.meta.id}-completed`;
+export function loadCompleted() {
+    const saved = localStorage.getItem(storageKey);
+    return saved ? JSON.parse(saved) : {};
+}
+export function saveCompleted(completed) {
+    localStorage.setItem(storageKey, JSON.stringify(completed));
+}

package/dist/viewer/stores/settings.d.ts

@@ -0,0 +1,53 @@
+export interface HrZone {
+    zone: number;
+    name: string;
+    low: number;
+    high: number;
+}
+export interface PowerZone {
+    zone: number;
+    name: string;
+    low: number;
+    high: number;
+}
+export interface PaceZone {
+    zone: string | number;
+    name: string;
+    pace: string;
+    offset?: number;
+}
+export type Theme = "dark" | "light";
+export interface Settings {
+    theme: Theme;
+    units: {
+        swim: "meters" | "yards";
+        bike: "kilometers" | "miles";
+        run: "kilometers" | "miles";
+    };
+    firstDayOfWeek: "monday" | "sunday";
+    run: {
+        lthr: number;
+        hrZones: HrZone[];
+        thresholdPace: string;
+        paceZones: PaceZone[];
+    };
+    bike: {
+        lthr: number;
+        hrZones: HrZone[];
+        ftp: number;
+        powerZones: PowerZone[];
+    };
+    swim: {
+        css: string;
+        cssSeconds: number;
+        paceZones: PaceZone[];
+    };
+}
+export declare function loadSettings(): Settings;
+export declare function saveSettings(settings: Settings): void;
+export declare function paceToSeconds(pace: string): number;
+export declare function secondsToPace(seconds: number): string;
+export declare function recalculateHrZones(lthr: number): HrZone[];
+export declare function recalculatePowerZones(ftp: number): PowerZone[];
+export declare function recalculateRunPaceZones(thresholdPace: string): PaceZone[];
+export declare function recalculateSwimPaceZones(css: string): PaceZone[];

package/dist/viewer/stores/settings.js

@@ -0,0 +1,207 @@
+import { planData } from "./plan.js";
+const defaultSettings = {
+    theme: "dark",
+    units: { swim: "meters", bike: "kilometers", run: "kilometers" },
+    firstDayOfWeek: "monday",
+    run: {
+        lthr: 165,
+        hrZones: [
+            { zone: 1, name: "Recovery", low: 0, high: 134 },
+            { zone: 2, name: "Aerobic", low: 134, high: 147 },
+            { zone: 3, name: "Tempo", low: 147, high: 156 },
+            { zone: 4, name: "Threshold", low: 156, high: 165 },
+            { zone: 5, name: "VO2max", low: 165, high: 180 },
+        ],
+        thresholdPace: "4:30",
+        paceZones: [
+            { zone: "E", name: "Easy", pace: "5:20" },
+            { zone: "M", name: "Marathon", pace: "4:50" },
+            { zone: "T", name: "Threshold", pace: "4:30" },
+            { zone: "I", name: "Interval", pace: "4:00" },
+            { zone: "R", name: "Repetition", pace: "3:40" },
+        ],
+    },
+    bike: {
+        lthr: 160,
+        hrZones: [
+            { zone: 1, name: "Recovery", low: 0, high: 130 },
+            { zone: 2, name: "Aerobic", low: 130, high: 142 },
+            { zone: 3, name: "Tempo", low: 142, high: 151 },
+            { zone: 4, name: "Threshold", low: 151, high: 160 },
+            { zone: 5, name: "VO2max", low: 160, high: 175 },
+        ],
+        ftp: 200,
+        powerZones: [
+            { zone: 1, name: "Active Recovery", low: 0, high: 110 },
+            { zone: 2, name: "Endurance", low: 110, high: 150 },
+            { zone: 3, name: "Tempo", low: 150, high: 180 },
+            { zone: 4, name: "Threshold", low: 180, high: 210 },
+            { zone: 5, name: "VO2max", low: 210, high: 240 },
+        ],
+    },
+    swim: {
+        css: "1:50",
+        cssSeconds: 110,
+        paceZones: [
+            { zone: 1, name: "Recovery", offset: 20, pace: "2:10" },
+            { zone: 2, name: "Aerobic", offset: 10, pace: "2:00" },
+            { zone: 3, name: "Tempo", offset: 5, pace: "1:55" },
+            { zone: 4, name: "Threshold", offset: 0, pace: "1:50" },
+            { zone: 5, name: "VO2max", offset: -5, pace: "1:45" },
+        ],
+    },
+};
+const storageKey = `plan-${planData.meta.id}-settings`;
+export function loadSettings() {
+    const settings = JSON.parse(JSON.stringify(defaultSettings));
+    // Merge with plan preferences
+    if (planData.preferences) {
+        settings.units.swim = planData.preferences.swim || settings.units.swim;
+        settings.units.bike = planData.preferences.bike || settings.units.bike;
+        settings.units.run = planData.preferences.run || settings.units.run;
+        settings.firstDayOfWeek = planData.preferences.firstDayOfWeek || settings.firstDayOfWeek;
+    }
+    // Merge with plan zones
+    const zones = planData.zones;
+    if (zones?.run?.hr) {
+        settings.run.lthr = zones.run.hr.lthr;
+        settings.run.hrZones = zones.run.hr.zones.map((z) => ({
+            zone: z.zone,
+            name: z.name,
+            low: z.hrLow,
+            high: z.hrHigh,
+        }));
+    }
+    if (zones?.run?.pace) {
+        settings.run.thresholdPace = zones.run.pace.thresholdPace || settings.run.thresholdPace;
+        if (zones.run.pace.zones) {
+            settings.run.paceZones = zones.run.pace.zones.map((z) => ({
+                zone: z.zone,
+                name: z.name,
+                pace: z.pace,
+            }));
+        }
+    }
+    if (zones?.bike?.hr) {
+        settings.bike.lthr = zones.bike.hr.lthr;
+        settings.bike.hrZones = zones.bike.hr.zones.map((z) => ({
+            zone: z.zone,
+            name: z.name,
+            low: z.hrLow,
+            high: z.hrHigh,
+        }));
+    }
+    if (zones?.bike?.power) {
+        settings.bike.ftp = zones.bike.power.ftp;
+        settings.bike.powerZones = zones.bike.power.zones.map((z) => ({
+            zone: z.zone,
+            name: z.name,
+            low: z.wattsLow,
+            high: z.wattsHigh,
+        }));
+    }
+    if (zones?.swim) {
+        settings.swim.css = zones.swim.css || settings.swim.css;
+        settings.swim.cssSeconds = zones.swim.cssSeconds || settings.swim.cssSeconds;
+        if (zones.swim.zones) {
+            settings.swim.paceZones = zones.swim.zones.map((z) => ({
+                zone: z.zone,
+                name: z.name,
+                offset: z.paceOffset,
+                pace: z.pace,
+            }));
+        }
+    }
+    // Override with user's saved settings
+    const saved = localStorage.getItem(storageKey);
+    if (saved) {
+        const userSettings = JSON.parse(saved);
+        if (userSettings.theme)
+            settings.theme = userSettings.theme;
+        if (userSettings.units)
+            settings.units = { ...settings.units, ...userSettings.units };
+        if (userSettings.firstDayOfWeek)
+            settings.firstDayOfWeek = userSettings.firstDayOfWeek;
+        if (userSettings.run)
+            settings.run = { ...settings.run, ...userSettings.run };
+        if (userSettings.bike)
+            settings.bike = { ...settings.bike, ...userSettings.bike };
+        if (userSettings.swim)
+            settings.swim = { ...settings.swim, ...userSettings.swim };
+    }
+    return settings;
+}
+export function saveSettings(settings) {
+    localStorage.setItem(storageKey, JSON.stringify(settings));
+}
+// Utility functions
+export function paceToSeconds(pace) {
+    const parts = pace.split(":");
+    return parseInt(parts[0]) * 60 + parseInt(parts[1] || "0");
+}
+export function secondsToPace(seconds) {
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.round(seconds % 60);
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+export function recalculateHrZones(lthr) {
+    const percentages = [
+        { zone: 1, name: "Recovery", lowPct: 0, highPct: 81 },
+        { zone: 2, name: "Aerobic", lowPct: 81, highPct: 89 },
+        { zone: 3, name: "Tempo", lowPct: 89, highPct: 94 },
+        { zone: 4, name: "Threshold", lowPct: 94, highPct: 100 },
+        { zone: 5, name: "VO2max", lowPct: 100, highPct: 106 },
+    ];
+    return percentages.map((p) => ({
+        zone: p.zone,
+        name: p.name,
+        low: Math.round((lthr * p.lowPct) / 100),
+        high: Math.round((lthr * p.highPct) / 100),
+    }));
+}
+export function recalculatePowerZones(ftp) {
+    const percentages = [
+        { zone: 1, name: "Active Recovery", lowPct: 0, highPct: 55 },
+        { zone: 2, name: "Endurance", lowPct: 55, highPct: 75 },
+        { zone: 3, name: "Tempo", lowPct: 75, highPct: 90 },
+        { zone: 4, name: "Threshold", lowPct: 90, highPct: 105 },
+        { zone: 5, name: "VO2max", lowPct: 105, highPct: 120 },
+    ];
+    return percentages.map((p) => ({
+        zone: p.zone,
+        name: p.name,
+        low: Math.round((ftp * p.lowPct) / 100),
+        high: Math.round((ftp * p.highPct) / 100),
+    }));
+}
+export function recalculateRunPaceZones(thresholdPace) {
+    const tSeconds = paceToSeconds(thresholdPace);
+    const zones = [
+        { zone: "E", name: "Easy", factor: 1.18 },
+        { zone: "M", name: "Marathon", factor: 1.07 },
+        { zone: "T", name: "Threshold", factor: 1.0 },
+        { zone: "I", name: "Interval", factor: 0.89 },
+        { zone: "R", name: "Repetition", factor: 0.82 },
+    ];
+    return zones.map((z) => ({
+        zone: z.zone,
+        name: z.name,
+        pace: secondsToPace(Math.round(tSeconds * z.factor)),
+    }));
+}
+export function recalculateSwimPaceZones(css) {
+    const cssSeconds = paceToSeconds(css);
+    const offsets = [
+        { zone: 1, name: "Recovery", offset: 20 },
+        { zone: 2, name: "Aerobic", offset: 10 },
+        { zone: 3, name: "Tempo", offset: 5 },
+        { zone: 4, name: "Threshold", offset: 0 },
+        { zone: 5, name: "VO2max", offset: -5 },
+    ];
+    return offsets.map((z) => ({
+        zone: z.zone,
+        name: z.name,
+        offset: z.offset,
+        pace: secondsToPace(cssSeconds + z.offset),
+    }));
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "claude-coach",
+  "version": "0.0.1",
+  "author": "Felix Rieseberg <felix@felixrieseberg.com> (https://felixrieseberg.com)",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "claude-coach": "bin/claude-coach.js"
+  },
+  "files": [
+    "bin",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "templates"
+  ],
+  "scripts": {
+    "start": "tsx src/cli.ts",
+    "build": "npm run build:ts && npm run build:viewer && npm run build:skill",
+    "build:ts": "tsc",
+    "build:viewer": "vite build --config vite.config.viewer.ts",
+    "build:skill": "mkdir -p dist && cd skill && zip -r ../dist/coach-skill.zip . -x '*.DS_Store' && echo 'Skill packaged to dist/coach-skill.zip'",
+    "dev": "tsx watch src/cli.ts",
+    "dev:viewer": "vite --config vite.config.viewer.ts",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepare": "husky",
+    "prepublishOnly": "npm run build"
+  },
+  "lint-staged": {
+    "*.{js,ts,json,md,html,css,svelte}": "prettier --write"
+  },
+  "dependencies": {
+    "@garmin/fitsdk": "^21.178.0",
+    "consola": "^3.2.3",
+    "jszip": "^3.10.1",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^6.2.1",
+    "@types/node": "^22.10.2",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.4.2",
+    "prettier-plugin-svelte": "^3.4.1",
+    "svelte": "^5.43.12",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vite": "^7.2.6",
+    "vite-plugin-singlefile": "^2.3.0",
+    "vitest": "^3.2.4"
+  }
+}