@robinthues/rt-claude-coach 0.1.0

package/dist/db/client.js

@@ -0,0 +1,111 @@
+import { execSync, spawnSync } from "child_process";
+import { getDbPath } from "../lib/config.js";
+let cachedBackend = null;
+/**
+ * Try to use Node's built-in SQLite module (Node 22.5+).
+ * Falls back to shelling out to sqlite3 CLI if not available.
+ */
+async function detectBackend() {
+    // Try Node.js built-in SQLite first (Node 22.5+)
+    try {
+        // Dynamic import to avoid syntax errors on older Node versions
+        const sqlite = await import("node:sqlite");
+        const dbPath = getDbPath();
+        const db = new sqlite.DatabaseSync(dbPath);
+        return {
+            query(sql) {
+                const stmt = db.prepare(sql);
+                const rows = stmt.all();
+                if (rows.length === 0)
+                    return "";
+                // Format as simple text output (column values separated by |)
+                return rows
+                    .map((row) => Object.values(row)
+                    .map((v) => (v === null ? "" : String(v)))
+                    .join("|"))
+                    .join("\n");
+            },
+            queryJson(sql) {
+                const stmt = db.prepare(sql);
+                return stmt.all();
+            },
+            execute(sql) {
+                db.exec(sql);
+            },
+        };
+    }
+    catch {
+        // Node.js built-in SQLite not available, try CLI
+    }
+    // Fallback: Use sqlite3 CLI
+    try {
+        // Check if sqlite3 is available
+        execSync("sqlite3 --version", { stdio: "ignore" });
+        return {
+            query(sql) {
+                const dbPath = getDbPath();
+                return execSync(`sqlite3 "${dbPath}" "${sql.replace(/"/g, '\\"')}"`, {
+                    encoding: "utf-8",
+                });
+            },
+            queryJson(sql) {
+                const dbPath = getDbPath();
+                const result = execSync(`sqlite3 -json "${dbPath}" "${sql.replace(/"/g, '\\"')}"`, {
+                    encoding: "utf-8",
+                });
+                if (!result.trim())
+                    return [];
+                return JSON.parse(result);
+            },
+            execute(sql) {
+                const dbPath = getDbPath();
+                const result = spawnSync("sqlite3", [dbPath], {
+                    input: sql,
+                    encoding: "utf-8",
+                });
+                if (result.error)
+                    throw result.error;
+                if (result.status !== 0) {
+                    throw new Error(`SQLite error: ${result.stderr}`);
+                }
+            },
+        };
+    }
+    catch {
+        throw new Error("SQLite is not available. Please either:\n" +
+            "  1. Use Node.js 22.5+ (has built-in SQLite)\n" +
+            "  2. Install sqlite3 CLI (brew install sqlite3 / apt install sqlite3)");
+    }
+}
+/**
+ * Initialize the SQLite backend. Must be called before using other functions.
+ */
+export async function initDatabase() {
+    if (!cachedBackend) {
+        cachedBackend = await detectBackend();
+    }
+}
+/**
+ * Get the backend, throwing if not initialized.
+ */
+function getBackend() {
+    if (!cachedBackend) {
+        throw new Error("Database not initialized. Call initDatabase() first.");
+    }
+    return cachedBackend;
+}
+// ============================================================================
+// Public API (synchronous after initialization)
+// ============================================================================
+export function query(sql) {
+    return getBackend().query(sql);
+}
+export function queryJson(sql) {
+    return getBackend().queryJson(sql);
+}
+export function execute(sql) {
+    getBackend().execute(sql);
+}
+export function runScript(script) {
+    execute(script);
+}

package/dist/db/migrate.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureColumns(): void;
+export declare function migrate(): void;

package/dist/db/migrate.js

@@ -0,0 +1,30 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { execute, queryJson, runScript } from "./client.js";
+import { ensureConfigDir } from "../lib/config.js";
+import { log } from "../lib/logging.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Columns added after the initial schema shipped. CREATE TABLE IF NOT EXISTS
+// never alters existing tables, so these are applied via ALTER TABLE.
+const COLUMN_MIGRATIONS = [
+    { table: "activities", column: "private_note", type: "TEXT" },
+    { table: "activities", column: "details_synced_at", type: "TEXT" },
+    { table: "sync_log", column: "details_synced", type: "INTEGER" },
+];
+export function ensureColumns() {
+    for (const { table, column, type } of COLUMN_MIGRATIONS) {
+        const existing = queryJson(`SELECT name FROM pragma_table_info('${table}');`).map((row) => row.name);
+        if (!existing.includes(column)) {
+            execute(`ALTER TABLE ${table} ADD COLUMN ${column} ${type};`);
+        }
+    }
+}
+export function migrate() {
+    ensureConfigDir();
+    const schemaPath = join(__dirname, "schema.sql");
+    const schema = readFileSync(schemaPath, "utf-8");
+    runScript(schema);
+    ensureColumns();
+    log.success("Database schema initialized");
+}

package/dist/db/schema.sql

@@ -0,0 +1,108 @@
+-- Core activity data
+CREATE TABLE IF NOT EXISTS activities (
+  id INTEGER PRIMARY KEY,           -- Strava activity ID
+  name TEXT,
+  sport_type TEXT,                  -- Run, Ride, Swim, etc.
+  start_date TEXT,                  -- ISO 8601 UTC
+  elapsed_time INTEGER,             -- seconds
+  moving_time INTEGER,              -- seconds
+  distance REAL,                    -- meters
+  total_elevation_gain REAL,        -- meters
+  average_speed REAL,               -- m/s
+  max_speed REAL,                   -- m/s
+  average_heartrate REAL,
+  max_heartrate REAL,
+  average_watts REAL,               -- cycling/running power
+  max_watts REAL,
+  weighted_average_watts REAL,      -- normalized power
+  kilojoules REAL,
+  suffer_score INTEGER,             -- Strava's relative effort
+  average_cadence REAL,
+  calories REAL,
+  description TEXT,
+  private_note TEXT,
+  workout_type INTEGER,             -- 0=default, 1=race, 2=workout, 3=long run
+  gear_id TEXT,
+  raw_json TEXT,                    -- full Strava response as JSON
+  details_synced_at TEXT,           -- last successful detail fetch (NULL = needs backfill)
+  synced_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Time-series streams (HR, power, pace over time)
+CREATE TABLE IF NOT EXISTS streams (
+  activity_id INTEGER PRIMARY KEY,
+  time_data TEXT,                   -- JSON array: seconds from start
+  distance_data TEXT,               -- JSON array: cumulative meters
+  heartrate_data TEXT,              -- JSON array
+  watts_data TEXT,                  -- JSON array
+  cadence_data TEXT,                -- JSON array
+  altitude_data TEXT,               -- JSON array
+  velocity_data TEXT,               -- JSON array: m/s
+  FOREIGN KEY (activity_id) REFERENCES activities(id)
+);
+
+-- Athlete profile
+CREATE TABLE IF NOT EXISTS athlete (
+  id INTEGER PRIMARY KEY,
+  firstname TEXT,
+  lastname TEXT,
+  weight REAL,                      -- kg
+  ftp INTEGER,                      -- functional threshold power (watts)
+  max_heartrate INTEGER,
+  raw_json TEXT,
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Training goals
+CREATE TABLE IF NOT EXISTS goals (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  event_name TEXT,                  -- "Ironman 70.3 Oceanside"
+  event_date TEXT,                  -- ISO 8601
+  event_type TEXT,                  -- triathlon, marathon, ultra, century
+  notes TEXT,                       -- constraints, injuries, etc.
+  created_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Sync metadata
+CREATE TABLE IF NOT EXISTS sync_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  started_at TEXT,
+  completed_at TEXT,
+  activities_synced INTEGER,
+  details_synced INTEGER,
+  status TEXT                       -- success, failed, partial
+);
+
+-- Indexes for common queries
+CREATE INDEX IF NOT EXISTS idx_activities_date ON activities(start_date);
+CREATE INDEX IF NOT EXISTS idx_activities_sport ON activities(sport_type);
+CREATE INDEX IF NOT EXISTS idx_activities_sport_date ON activities(sport_type, start_date);
+
+-- Useful views
+DROP VIEW IF EXISTS weekly_volume;
+CREATE VIEW weekly_volume AS
+SELECT
+  strftime('%Y-W%W', start_date) AS week,
+  sport_type,
+  COUNT(*) AS sessions,
+  ROUND(SUM(moving_time) / 3600.0, 1) AS hours,
+  ROUND(SUM(distance) / 1000.0, 1) AS km,
+  ROUND(AVG(average_heartrate), 0) AS avg_hr,
+  ROUND(AVG(suffer_score), 0) AS avg_effort
+FROM activities
+GROUP BY week, sport_type
+ORDER BY week DESC, sport_type;
+
+DROP VIEW IF EXISTS recent_activities;
+CREATE VIEW recent_activities AS
+SELECT
+  date(start_date) AS date,
+  sport_type,
+  name,
+  moving_time / 60 AS minutes,
+  ROUND(distance / 1000.0, 1) AS km,
+  ROUND(average_heartrate, 0) AS hr,
+  suffer_score
+FROM activities
+ORDER BY start_date DESC
+LIMIT 50;

package/dist/garmin/context.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Plan-side helper types and zone narrowing for the Garmin converter.
+ */
+import type { AthleteZones, Sport } from "../schema/training-plan.js";
+import type { TargetTypeDTO } from "./dto.js";
+export interface SportZones {
+    hrZones?: {
+        zone: number;
+        name: string;
+        hrLow: number;
+        hrHigh: number;
+    }[];
+    paceZones?: {
+        zone: string | number;
+        name: string;
+        pace: string;
+    }[];
+}
+export interface TargetResolution {
+    targetType: TargetTypeDTO;
+    targetValueOne?: number;
+    targetValueTwo?: number;
+}
+export interface ConvertContext {
+    sportZones: SportZones;
+}
+/**
+ * Narrow the plan's AthleteZones to the HR and pace zone tables for one sport.
+ * run and trailrun both read zones.run; other sports return {} (no zone data).
+ */
+export declare function getSportZones(zones: AthleteZones, sport: Sport): SportZones;

package/dist/garmin/context.js

@@ -0,0 +1,25 @@
+/**
+ * Plan-side helper types and zone narrowing for the Garmin converter.
+ */
+/**
+ * Narrow the plan's AthleteZones to the HR and pace zone tables for one sport.
+ * run and trailrun both read zones.run; other sports return {} (no zone data).
+ */
+export function getSportZones(zones, sport) {
+    if ((sport === "run" || sport === "trailrun") && zones.run) {
+        return {
+            hrZones: zones.run.hr?.zones.map((z) => ({
+                zone: z.zone,
+                name: z.name,
+                hrLow: z.hrLow,
+                hrHigh: z.hrHigh,
+            })),
+            paceZones: zones.run.pace?.zones.map((z) => ({
+                zone: z.zone,
+                name: z.name,
+                pace: z.pace,
+            })),
+        };
+    }
+    return {};
+}

package/dist/garmin/convert.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Convert a Claude Coach TrainingPlan into Garmin sync entries.
+ *
+ * Pure and deterministic: no clock, no network. Rest days, race entries, and
+ * out-of-scope sports (bike/swim) are skipped. Each remaining workout becomes a
+ * { calendarDate, workout } entry compatible with the Garmin MCP upload_workouts.
+ */
+import type { TrainingPlan, TrainingWeek, TrainingDay, Workout, Sport } from "../schema/training-plan.js";
+import { type SportTypeDTO, type WorkoutDTO, type GarminSyncEntry } from "./dto.js";
+import { type ConvertContext } from "./context.js";
+/** Map a Claude Coach sport to a Garmin sport type, or null if not schedulable. */
+export declare function mapSport(sport: Sport): SportTypeDTO | null;
+/** Derive a short plan tag from event initials + two-digit event year. */
+export declare function derivePlanTag(plan: TrainingPlan): string;
+/** Build the tagged workout name, e.g. "[HIO26] W3 Tue — Tempo". */
+export declare function workoutName(tag: string, week: TrainingWeek, day: TrainingDay, workout: Workout): string;
+export declare function convertWorkout(workout: Workout, sportType: SportTypeDTO, ctx: ConvertContext, name: string): WorkoutDTO;
+export interface WorkoutFilter {
+    /** Export only the workout with this id. */
+    workoutId?: string;
+    /** Export only workouts on this ISO date (YYYY-MM-DD). */
+    date?: string;
+}
+export interface ConvertOptions {
+    tag?: string;
+    filter?: WorkoutFilter;
+}
+export declare function convertPlan(plan: TrainingPlan, options?: ConvertOptions): GarminSyncEntry[];

package/dist/garmin/convert.js

@@ -0,0 +1,117 @@
+/**
+ * Convert a Claude Coach TrainingPlan into Garmin sync entries.
+ *
+ * Pure and deterministic: no clock, no network. Rest days, race entries, and
+ * out-of-scope sports (bike/swim) are skipped. Each remaining workout becomes a
+ * { calendarDate, workout } entry compatible with the Garmin MCP upload_workouts.
+ */
+import { SPORT_TYPES } from "./dto.js";
+import { getSportZones } from "./context.js";
+import { buildStructuredSteps, buildSimpleSteps } from "./steps.js";
+const STOP_WORDS = new Set(["the", "of", "and", "a", "70.3", "703"]);
+/** Map a Claude Coach sport to a Garmin sport type, or null if not schedulable. */
+export function mapSport(sport) {
+    switch (sport) {
+        case "run":
+        case "trailrun":
+            // Garmin has no distinct trail-running workout sport; a trail run is a
+            // running workout with identical steps/targets.
+            return SPORT_TYPES.running;
+        case "strength":
+            return SPORT_TYPES.strength_training;
+        default:
+            return null; // rest, race, bike, swim, brick -> skip
+    }
+}
+/** Derive a short plan tag from event initials + two-digit event year. */
+export function derivePlanTag(plan) {
+    const initials = plan.meta.event
+        .split(/\s+/)
+        .filter((word) => word.length > 0 && !STOP_WORDS.has(word.toLowerCase()))
+        .map((word) => word[0].toUpperCase())
+        .filter((ch) => /[A-Z]/.test(ch))
+        .join("");
+    const year = plan.meta.eventDate.slice(2, 4);
+    return `${initials}${year}`;
+}
+const DAY_ABBREV = {
+    monday: "Mon",
+    tuesday: "Tue",
+    wednesday: "Wed",
+    thursday: "Thu",
+    friday: "Fri",
+    saturday: "Sat",
+    sunday: "Sun",
+};
+function titleCase(s) {
+    return s.length ? s[0].toUpperCase() + s.slice(1) : s;
+}
+/** Build the tagged workout name, e.g. "[HIO26] W3 Tue — Tempo". */
+export function workoutName(tag, week, day, workout) {
+    const abbrev = DAY_ABBREV[day.dayOfWeek.toLowerCase()] ?? day.dayOfWeek.slice(0, 3);
+    return `[${tag}] W${week.weekNumber} ${abbrev} — ${titleCase(workout.type)}`;
+}
+export function convertWorkout(workout, sportType, ctx, name) {
+    const steps = workout.structure
+        ? buildStructuredSteps(workout.structure, ctx)
+        : buildSimpleSteps(workout, ctx);
+    return {
+        workoutName: name,
+        sportType,
+        workoutSegments: [
+            {
+                segmentOrder: 1,
+                sportType,
+                workoutSteps: steps,
+            },
+        ],
+    };
+}
+/** Structural validation — throws with a per-workout reason on failure. */
+function validateSchedulableWorkout(workout, name) {
+    if (!workout.structure && workout.durationMinutes === undefined) {
+        throw new Error(`Workout "${workout.name}" (${name}) has neither a structure nor durationMinutes — cannot build a Garmin workout.`);
+    }
+}
+/** True when this workout passes the (optional) subset filter. */
+function matchesFilter(workout, day, filter) {
+    if (!filter)
+        return true;
+    if (filter.workoutId !== undefined && workout.id !== filter.workoutId)
+        return false;
+    if (filter.date !== undefined && day.date !== filter.date)
+        return false;
+    return true;
+}
+export function convertPlan(plan, options = {}) {
+    if (!plan.weeks) {
+        throw new Error("Plan has no weeks array.");
+    }
+    const tag = options.tag ?? derivePlanTag(plan);
+    const entries = [];
+    for (const week of plan.weeks) {
+        for (const day of week.days) {
+            for (const workout of day.workouts) {
+                if (!matchesFilter(workout, day, options.filter))
+                    continue;
+                const sportType = mapSport(workout.sport);
+                if (!sportType)
+                    continue; // rest, race, bike, swim -> skip
+                const name = workoutName(tag, week, day, workout);
+                validateSchedulableWorkout(workout, name);
+                const ctx = { sportZones: getSportZones(plan.zones, workout.sport) };
+                entries.push({
+                    calendarDate: day.date,
+                    workout: convertWorkout(workout, sportType, ctx, name),
+                });
+            }
+        }
+    }
+    if (options.filter && entries.length === 0) {
+        const desc = options.filter.workoutId
+            ? `id "${options.filter.workoutId}"`
+            : `date "${options.filter.date}"`;
+        throw new Error(`Filter matched no schedulable workout (${desc}).`);
+    }
+    return entries;
+}

package/dist/garmin/dto.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Garmin Connect workout DTO types and enum constants.
+ *
+ * These shapes mirror Garmin Connect's native workout JSON, which the Garmin
+ * MCP `upload_workouts` tool consumes. Output shapes only — no plan-side imports.
+ *
+ * Enum IDs pinned by the design spec:
+ *   repeat end condition -> conditionTypeId 7 / "iterations"
+ *   heart-rate-zone target -> workoutTargetTypeId 4
+ *   pace-zone target -> workoutTargetTypeId 6
+ *   no-target -> workoutTargetTypeId 1
+ */
+export interface SportTypeDTO {
+    sportTypeId: number;
+    sportTypeKey: string;
+}
+export interface StepTypeDTO {
+    stepTypeId: number;
+    stepTypeKey: string;
+}
+export interface EndConditionDTO {
+    conditionTypeId: number;
+    conditionTypeKey: string;
+}
+export interface TargetTypeDTO {
+    workoutTargetTypeId: number;
+    workoutTargetTypeKey: string;
+}
+export interface ExecutableStepDTO {
+    type: "ExecutableStepDTO";
+    stepId: number;
+    stepOrder: number;
+    stepType: StepTypeDTO;
+    endCondition: EndConditionDTO;
+    endConditionValue: number;
+    targetType: TargetTypeDTO;
+    targetValueOne?: number;
+    targetValueTwo?: number;
+    description?: string;
+}
+export interface RepeatGroupDTO {
+    type: "RepeatGroupDTO";
+    stepId: number;
+    stepOrder: number;
+    stepType: StepTypeDTO;
+    numberOfIterations: number;
+    endCondition: EndConditionDTO;
+    workoutSteps: ExecutableStepDTO[];
+}
+export type WorkoutStepDTO = ExecutableStepDTO | RepeatGroupDTO;
+export interface WorkoutSegmentDTO {
+    segmentOrder: number;
+    sportType: SportTypeDTO;
+    workoutSteps: WorkoutStepDTO[];
+}
+export interface WorkoutDTO {
+    workoutName: string;
+    sportType: SportTypeDTO;
+    workoutSegments: WorkoutSegmentDTO[];
+}
+export interface GarminSyncEntry {
+    calendarDate: string;
+    workout: WorkoutDTO;
+}
+export declare const SPORT_TYPES: {
+    readonly running: {
+        readonly sportTypeId: 1;
+        readonly sportTypeKey: "running";
+    };
+    readonly strength_training: {
+        readonly sportTypeId: 5;
+        readonly sportTypeKey: "strength_training";
+    };
+};
+export declare const STEP_TYPES: {
+    readonly warmup: {
+        readonly stepTypeId: 1;
+        readonly stepTypeKey: "warmup";
+    };
+    readonly cooldown: {
+        readonly stepTypeId: 2;
+        readonly stepTypeKey: "cooldown";
+    };
+    readonly interval: {
+        readonly stepTypeId: 3;
+        readonly stepTypeKey: "interval";
+    };
+    readonly recovery: {
+        readonly stepTypeId: 4;
+        readonly stepTypeKey: "recovery";
+    };
+    readonly rest: {
+        readonly stepTypeId: 5;
+        readonly stepTypeKey: "rest";
+    };
+    readonly repeat: {
+        readonly stepTypeId: 6;
+        readonly stepTypeKey: "repeat";
+    };
+};
+export declare const END_CONDITIONS: {
+    readonly lapButton: {
+        readonly conditionTypeId: 1;
+        readonly conditionTypeKey: "lap.button";
+    };
+    readonly time: {
+        readonly conditionTypeId: 2;
+        readonly conditionTypeKey: "time";
+    };
+    readonly distance: {
+        readonly conditionTypeId: 3;
+        readonly conditionTypeKey: "distance";
+    };
+    readonly iterations: {
+        readonly conditionTypeId: 7;
+        readonly conditionTypeKey: "iterations";
+    };
+};
+export declare const TARGET_TYPES: {
+    readonly noTarget: {
+        readonly workoutTargetTypeId: 1;
+        readonly workoutTargetTypeKey: "no.target";
+    };
+    readonly heartRateZone: {
+        readonly workoutTargetTypeId: 4;
+        readonly workoutTargetTypeKey: "heart.rate.zone";
+    };
+    readonly paceZone: {
+        readonly workoutTargetTypeId: 6;
+        readonly workoutTargetTypeKey: "pace.zone";
+    };
+};

package/dist/garmin/dto.js

@@ -0,0 +1,35 @@
+/**
+ * Garmin Connect workout DTO types and enum constants.
+ *
+ * These shapes mirror Garmin Connect's native workout JSON, which the Garmin
+ * MCP `upload_workouts` tool consumes. Output shapes only — no plan-side imports.
+ *
+ * Enum IDs pinned by the design spec:
+ *   repeat end condition -> conditionTypeId 7 / "iterations"
+ *   heart-rate-zone target -> workoutTargetTypeId 4
+ *   pace-zone target -> workoutTargetTypeId 6
+ *   no-target -> workoutTargetTypeId 1
+ */
+export const SPORT_TYPES = {
+    running: { sportTypeId: 1, sportTypeKey: "running" },
+    strength_training: { sportTypeId: 5, sportTypeKey: "strength_training" },
+};
+export const STEP_TYPES = {
+    warmup: { stepTypeId: 1, stepTypeKey: "warmup" },
+    cooldown: { stepTypeId: 2, stepTypeKey: "cooldown" },
+    interval: { stepTypeId: 3, stepTypeKey: "interval" },
+    recovery: { stepTypeId: 4, stepTypeKey: "recovery" },
+    rest: { stepTypeId: 5, stepTypeKey: "rest" },
+    repeat: { stepTypeId: 6, stepTypeKey: "repeat" },
+};
+export const END_CONDITIONS = {
+    lapButton: { conditionTypeId: 1, conditionTypeKey: "lap.button" },
+    time: { conditionTypeId: 2, conditionTypeKey: "time" },
+    distance: { conditionTypeId: 3, conditionTypeKey: "distance" },
+    iterations: { conditionTypeId: 7, conditionTypeKey: "iterations" },
+};
+export const TARGET_TYPES = {
+    noTarget: { workoutTargetTypeId: 1, workoutTargetTypeKey: "no.target" },
+    heartRateZone: { workoutTargetTypeId: 4, workoutTargetTypeKey: "heart.rate.zone" },
+    paceZone: { workoutTargetTypeId: 6, workoutTargetTypeKey: "pace.zone" },
+};

package/dist/garmin/index.d.ts

@@ -0,0 +1,3 @@
+export { convertPlan } from "./convert.js";
+export type { WorkoutFilter, ConvertOptions } from "./convert.js";
+export type { GarminSyncEntry, WorkoutDTO } from "./dto.js";

package/dist/garmin/index.js

@@ -0,0 +1 @@
+export { convertPlan } from "./convert.js";

package/dist/garmin/pace.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parse a running pace string into speed (metres per second), the unit Garmin
+ * pace.zone targets use. Supports "M:SS/km", "MM:SS/mi", and bare "M:SS"
+ * (assumed per-kilometre). Throws on unparseable input.
+ */
+export declare function parsePaceToMetersPerSecond(pace: string): number;

package/dist/garmin/pace.js

@@ -0,0 +1,23 @@
+/**
+ * Parse a running pace string into speed (metres per second), the unit Garmin
+ * pace.zone targets use. Supports "M:SS/km", "MM:SS/mi", and bare "M:SS"
+ * (assumed per-kilometre). Throws on unparseable input.
+ */
+const METERS_PER_MILE = 1609.344;
+const METERS_PER_KM = 1000;
+export function parsePaceToMetersPerSecond(pace) {
+    const trimmed = pace.trim();
+    const match = trimmed.match(/^(\d+):(\d{2})(?:\s*\/\s*(km|mi))?$/i);
+    if (!match) {
+        throw new Error(`Unparseable pace: "${pace}"`);
+    }
+    const minutes = Number(match[1]);
+    const seconds = Number(match[2]);
+    const unit = (match[3] ?? "km").toLowerCase();
+    const totalSeconds = minutes * 60 + seconds;
+    if (totalSeconds <= 0) {
+        throw new Error(`Pace must be greater than zero: "${pace}"`);
+    }
+    const meters = unit === "mi" ? METERS_PER_MILE : METERS_PER_KM;
+    return meters / totalSeconds;
+}

package/dist/garmin/steps.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 type { StructuredWorkout, Workout } from "../schema/training-plan.js";
+import { type WorkoutStepDTO } from "./dto.js";
+import type { ConvertContext } from "./context.js";
+export declare function buildStructuredSteps(structure: StructuredWorkout, ctx: ConvertContext): WorkoutStepDTO[];
+export declare function buildSimpleSteps(workout: Workout, ctx: ConvertContext): WorkoutStepDTO[];