claude-coach 0.0.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025 Felix Rieseberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# Claude Coach
+
+Claude Coach allows you to use Claude to create custom-tailored training programs for triathlons, marathons, and other endurance activities. Using a data-driven approach and principles from top training plans, Claude will create a training plan that's uniquely fit for you, your personal fitness, and the constraints you have in the next couple of weeks. Maybe you're recovering from an injury, maybe you're traveling and don't have access to a pool or track in a certain week - tell Claude about it and it'll create a plan that works for you.
+
+The output is a beautiful training plan app that allows you to add, edit, or move workouts, mark them as complete, and update key training data like heart rate zones, LTHR, threshold paces, FTP, and others. Your data is kept locally in your browser.
+
+Workouts can be exported as simple calendar events (.ics), Zwift (.zwo), Garmin (.fit), or TrainerRoad/ERG (.mrc) workouts.
+
+## Example
+
+## Installation & Creating a training plan
+
+I happen to work at Anthropic, so this tool is optimized for Claude. To use this tool, you need access to Claude.ai or Claude Code with network access for Skills. Depending on user/admin settings, Skills may have full, partial, or no network access.
+
+### Installing the Skill
+
+First, [download the latest skill from GitHub Releases](https://github.com/felixrieseberg/claude-coach/releases/latest/download/coach-skill.zip).
+
+- If you're using Claude.ai, open the Settings, navigate to Capabilities, then click the `+ Add` button. Upload the `coach-skill.zip` file you just downloaded.
+- If you're using Claude Code, run `/install-skill` and provide the path to the `coach-skill.zip` file you downloaded.
+
+### Creating a plan
+
+Prompt Claude with something like this:
+
+> Help me create a training plan for the Ironman 70.3 Oceanside on March 29th 2026 using the "coach" skill.
+
+Claude will ask how you'd like to provide your fitness data. You have two options: You can either tell Claude about your fitness history manually - or you can give it access to your Strava activities. I recommend the later - data doesn't lie and more data allows Claude to make a training plan that really fits you.
+
+#### Option 1: Connect to Strava (Recommended)
+
+The easiest way to get a personalized plan is to let Claude analyze your Strava training history. This gives Claude real data about your current fitness, training patterns, and progress.
+
+Claude needs a `Client ID` and `Client Secret` to access your Strava activities. You're only giving Claude access to your data - nobody else gets to see it.
+
+1. Go to [strava.com/settings/api](https://www.strava.com/settings/api) and log in with your Strava account
+2. You'll see a form titled "My API Application" - fill it out:
+   - **Application Name**: Enter anything you like (e.g., "Claude Coach")
+   - **Category**: Select "Data Importer"
+   - **Club**: Leave this blank
+   - **Website**: Enter any URL (e.g., `https://claude.ai`)
+   - **Application Description**: Enter anything (e.g., "Training plan generation")
+   - **Authorization Callback Domain**: Enter `localhost`
+3. Check the box to agree to Strava's API Agreement and click **Create**
+4. Copy your **Client ID** and **Client Secret** and give them to Claude when prompted
+
+#### Option 2: Manual Entry
+
+Don't use Strava, or prefer not to connect it? No problem. You can tell Claude about your fitness directly. Be prepared to share:
+
+**Current Training (recent 4-8 weeks):**
+
+- Weekly training hours by sport (swim/bike/run)
+- Typical long session distances (longest ride, longest run, etc.)
+- Training consistency (how many weeks have you been training regularly?)
+
+**Performance Benchmarks (any you know):**
+
+- Bike FTP (Functional Threshold Power) in watts
+- Run threshold pace or recent race times (5K, 10K, half marathon, etc.)
+- Swim CSS (Critical Swim Speed) or recent time trial (e.g., 1000m time)
+- Max heart rate and/or lactate threshold heart rate
+
+### Telling Claude about your event & constraints
+
+In the next step, Claude will ask you about yourself, the event you're training for, and any constraints it should keep in mind. Examples of information you'd tell any coach:
+
+**Training History:**
+
+- Years in the sport
+- Previous races completed (distances and approximate times)
+- Any recent breaks from training
+
+**Constraints & Considerations:**
+
+- Injuries or health issues
+- Schedule limitations (work travel, family, etc.)
+- Equipment access (pool availability, trainer, etc.)
+
+Claude will use this information to create a plan tailored to your current fitness level. The more detail you provide, the better your plan will be.
+
+# About
+
+License: MIT.

package/bin/claude-coach.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cliPath = join(__dirname, "..", "dist", "cli.js");
+
+// Dynamically import the compiled CLI
+await import(cliPath);

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,277 @@
+import { configExists, loadConfig, promptForConfig, saveConfig, getDbPath, createConfig, } from "./lib/config.js";
+import { log } from "./lib/logging.js";
+import { migrate } from "./db/migrate.js";
+import { execute } from "./db/client.js";
+import { getValidTokens } from "./strava/oauth.js";
+import { getAllActivities, getAthlete } from "./strava/api.js";
+import { readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function parseArgs() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args[0] === "sync") {
+        // Sync command (default)
+        const syncArgs = { command: "sync" };
+        for (const arg of args) {
+            if (arg.startsWith("--client-id=")) {
+                syncArgs.clientId = arg.split("=")[1];
+            }
+            else if (arg.startsWith("--client-secret=")) {
+                syncArgs.clientSecret = arg.split("=")[1];
+            }
+            else if (arg.startsWith("--days=")) {
+                syncArgs.days = parseInt(arg.split("=")[1]);
+            }
+        }
+        return syncArgs;
+    }
+    if (args[0] === "render") {
+        if (!args[1]) {
+            log.error("render command requires an input file");
+            process.exit(1);
+        }
+        const renderArgs = {
+            command: "render",
+            inputFile: args[1],
+        };
+        for (let i = 2; i < args.length; i++) {
+            if (args[i] === "--output" || args[i] === "-o") {
+                renderArgs.outputFile = args[i + 1];
+                i++;
+            }
+            else if (args[i].startsWith("--output=")) {
+                renderArgs.outputFile = args[i].split("=")[1];
+            }
+        }
+        return renderArgs;
+    }
+    if (args[0] === "--help" || args[0] === "-h" || args[0] === "help") {
+        return { command: "help" };
+    }
+    log.error(`Unknown command: ${args[0]}`);
+    process.exit(1);
+}
+function printHelp() {
+    console.log(`
+Claude Coach - Training Plan Tools
+
+Usage: npx claude-coach <command> [options]
+
+Commands:
+  sync              Sync activities from Strava (default)
+  render <file>     Render a training plan JSON to HTML
+  help              Show this help message
+
+Sync Options:
+  --client-id=ID        Strava API client ID
+  --client-secret=SEC   Strava API client secret
+  --days=N              Days of history to sync (default: 730)
+
+Render Options:
+  --output, -o FILE     Output HTML file (default: <input>.html)
+
+Examples:
+  # Sync from Strava (interactive)
+  npx claude-coach
+
+  # Sync with credentials
+  npx claude-coach sync --client-id=12345 --client-secret=abc123
+
+  # Render a training plan to HTML
+  npx claude-coach render plan.json --output my-plan.html
+
+  # Render to stdout
+  npx claude-coach render plan.json
+`);
+}
+// ============================================================================
+// Sync Command
+// ============================================================================
+function escapeString(str) {
+    if (str == null)
+        return "NULL";
+    return `'${str.replace(/'/g, "''")}'`;
+}
+function insertActivity(activity) {
+    const sql = `
+    INSERT OR REPLACE INTO activities (
+      id, name, sport_type, start_date, elapsed_time, moving_time,
+      distance, total_elevation_gain, average_speed, max_speed,
+      average_heartrate, max_heartrate, average_watts, max_watts,
+      weighted_average_watts, kilojoules, suffer_score, average_cadence,
+      calories, description, workout_type, gear_id, raw_json, synced_at
+    ) VALUES (
+      ${activity.id},
+      ${escapeString(activity.name)},
+      ${escapeString(activity.sport_type)},
+      ${escapeString(activity.start_date)},
+      ${activity.elapsed_time ?? "NULL"},
+      ${activity.moving_time ?? "NULL"},
+      ${activity.distance ?? "NULL"},
+      ${activity.total_elevation_gain ?? "NULL"},
+      ${activity.average_speed ?? "NULL"},
+      ${activity.max_speed ?? "NULL"},
+      ${activity.average_heartrate ?? "NULL"},
+      ${activity.max_heartrate ?? "NULL"},
+      ${activity.average_watts ?? "NULL"},
+      ${activity.max_watts ?? "NULL"},
+      ${activity.weighted_average_watts ?? "NULL"},
+      ${activity.kilojoules ?? "NULL"},
+      ${activity.suffer_score ?? "NULL"},
+      ${activity.average_cadence ?? "NULL"},
+      ${activity.calories ?? "NULL"},
+      ${escapeString(activity.description)},
+      ${activity.workout_type ?? "NULL"},
+      ${escapeString(activity.gear_id)},
+      ${escapeString(JSON.stringify(activity))},
+      datetime('now')
+    );
+  `;
+    execute(sql);
+}
+function insertAthlete(athlete) {
+    const sql = `
+    INSERT OR REPLACE INTO athlete (id, firstname, lastname, weight, ftp, raw_json, updated_at)
+    VALUES (
+      ${athlete.id},
+      ${escapeString(athlete.firstname)},
+      ${escapeString(athlete.lastname)},
+      ${athlete.weight ?? "NULL"},
+      ${athlete.ftp ?? "NULL"},
+      ${escapeString(JSON.stringify(athlete))},
+      datetime('now')
+    );
+  `;
+    execute(sql);
+}
+async function runSync(args) {
+    log.box("Claude Coach - Strava Sync");
+    // Step 1: Check/create config
+    if (!configExists()) {
+        if (args.clientId && args.clientSecret) {
+            log.info("Creating configuration from command line arguments...");
+            const config = createConfig(args.clientId, args.clientSecret, args.days || 730);
+            saveConfig(config);
+            log.success("Configuration saved");
+        }
+        else {
+            log.info("No configuration found. Let's set things up.");
+            const config = await promptForConfig();
+            saveConfig(config);
+            log.success("Configuration saved");
+        }
+    }
+    const config = loadConfig();
+    const syncDays = args.days || config.sync_days || 730;
+    // Step 2: Initialize database
+    migrate();
+    // Step 3: Authenticate with Strava
+    const tokens = await getValidTokens();
+    // Step 4: Fetch and store athlete profile
+    log.start("Fetching athlete profile...");
+    const athlete = await getAthlete(tokens);
+    insertAthlete(athlete);
+    log.success(`Athlete: ${athlete.firstname} ${athlete.lastname}`);
+    // Step 5: Fetch activities
+    const afterDate = new Date();
+    afterDate.setDate(afterDate.getDate() - syncDays);
+    const activities = await getAllActivities(tokens, afterDate);
+    // Step 6: Store activities
+    log.start("Storing activities in database...");
+    let count = 0;
+    for (const activity of activities) {
+        insertActivity(activity);
+        count++;
+        if (count % 50 === 0) {
+            log.progress(`   Stored ${count}/${activities.length}...`);
+        }
+    }
+    log.progressEnd();
+    log.success(`Stored ${activities.length} activities`);
+    // Step 7: Log sync
+    execute(`
+    INSERT INTO sync_log (started_at, completed_at, activities_synced, status)
+    VALUES (datetime('now'), datetime('now'), ${activities.length}, 'success');
+  `);
+    log.info(`Database: ${getDbPath()}`);
+    log.ready(`Query with: sqlite3 -json "${getDbPath()}" "SELECT * FROM weekly_volume"`);
+}
+// ============================================================================
+// Render Command
+// ============================================================================
+function getTemplatePath() {
+    // Look for template in multiple locations
+    const locations = [
+        join(__dirname, "..", "templates", "plan-viewer.html"),
+        join(__dirname, "..", "..", "templates", "plan-viewer.html"),
+        join(process.cwd(), "templates", "plan-viewer.html"),
+    ];
+    for (const loc of locations) {
+        try {
+            readFileSync(loc);
+            return loc;
+        }
+        catch {
+            // Continue to next location
+        }
+    }
+    throw new Error("Could not find plan-viewer.html template");
+}
+function runRender(args) {
+    log.start("Rendering training plan...");
+    // Read the plan JSON
+    let planJson;
+    try {
+        planJson = readFileSync(args.inputFile, "utf-8");
+    }
+    catch (err) {
+        log.error(`Could not read input file: ${args.inputFile}`);
+        process.exit(1);
+    }
+    // Validate it's valid JSON
+    try {
+        JSON.parse(planJson);
+    }
+    catch (err) {
+        log.error("Input file is not valid JSON");
+        process.exit(1);
+    }
+    // Read the template
+    const templatePath = getTemplatePath();
+    let template = readFileSync(templatePath, "utf-8");
+    // Replace the plan data in the template
+    const planDataRegex = /<script type="application\/json" id="plan-data">[\s\S]*?<\/script>/;
+    const newPlanData = `<script type="application/json" id="plan-data">\n${planJson}\n</script>`;
+    template = template.replace(planDataRegex, newPlanData);
+    // Output
+    if (args.outputFile) {
+        writeFileSync(args.outputFile, template);
+        log.success(`Training plan rendered to: ${args.outputFile}`);
+    }
+    else {
+        // Output to stdout
+        console.log(template);
+    }
+}
+// ============================================================================
+// Main
+// ============================================================================
+async function main() {
+    const args = parseArgs();
+    switch (args.command) {
+        case "help":
+            printHelp();
+            break;
+        case "sync":
+            await runSync(args);
+            break;
+        case "render":
+            runRender(args);
+            break;
+    }
+}
+main().catch((err) => {
+    log.error(err.message);
+    process.exit(1);
+});

package/dist/db/client.d.ts

@@ -0,0 +1,4 @@
+export declare function query(sql: string): string;
+export declare function queryJson<T>(sql: string): T[];
+export declare function execute(sql: string): void;
+export declare function runScript(script: string): void;

package/dist/db/client.js

@@ -0,0 +1,45 @@
+import { execSync, spawnSync } from "child_process";
+import { getDbPath } from "../lib/config.js";
+export function query(sql) {
+    const dbPath = getDbPath();
+    try {
+        return execSync(`sqlite3 "${dbPath}" "${sql.replace(/"/g, '\\"')}"`, {
+            encoding: "utf-8",
+        });
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`SQLite error: ${err.stderr || err.message}`);
+    }
+}
+export function queryJson(sql) {
+    const dbPath = getDbPath();
+    try {
+        const result = execSync(`sqlite3 -json "${dbPath}" "${sql.replace(/"/g, '\\"')}"`, {
+            encoding: "utf-8",
+        });
+        if (!result.trim())
+            return [];
+        return JSON.parse(result);
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`SQLite error: ${err.stderr || err.message}`);
+    }
+}
+export function 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}`);
+    }
+}
+export function runScript(script) {
+    execute(script);
+}

package/dist/db/migrate.d.ts

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

package/dist/db/migrate.js

@@ -0,0 +1,14 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { runScript } from "./client.js";
+import { ensureConfigDir } from "../lib/config.js";
+import { log } from "../lib/logging.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function migrate() {
+    ensureConfigDir();
+    const schemaPath = join(__dirname, "schema.sql");
+    const schema = readFileSync(schemaPath, "utf-8");
+    runScript(schema);
+    log.success("Database schema initialized");
+}

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 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");
+    },
+};