@robinthues/rt-claude-coach 0.1.0

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,98 @@
+# Claude Coach
+
+> This is Robin's fork of
+> [felixrieseberg/claude-coach](https://github.com/felixrieseberg/claude-coach),
+> published as
+> [`@robinthues/rt-claude-coach`](https://www.npmjs.com/package/@robinthues/rt-claude-coach)
+> (CLI: `npx @robinthues/rt-claude-coach`). All credit for the original
+> project goes to Felix Rieseberg.
+
+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.
+
+## Examples
+
+See example training plans at [felixrieseberg.github.io/claude-coach](https://felixrieseberg.github.io/claude-coach/#demos).
+
+## 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.
+
+Syncing all your Strava activities and creating a tailored training plan takes ca. 15 minutes.
+
+### Installing the Skill
+
+First, [download the latest skill from this repo's GitHub Releases](https://github.com/RobinThues/rt-claude-coach/releases/latest/download/coach-skill.zip) (the repo is private, so you must be logged in to GitHub).
+
+**Claude.ai:**
+
+1. Open [Claude.ai Settings](https://claude.ai/settings/capabilities)
+2. Enable "Code execution and file creation"
+3. In the allowed domains list, add `*.strava.com`
+4. Scroll down to "Skills" and click "Add skill", then upload the `coach-skill.zip` file
+
+**Claude Code:**
+
+1. Run `/install-skill` and provide the path to the `coach-skill.zip` file you downloaded.
+
+### Creating a plan
+
+Use the most capable model available to you (as I'm writing this, that's Opus 4.5). 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:
+
+- Years in the sport
+- Previous races completed (distances and approximate times)
+- Any recent breaks from training
+- 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
+
+Claude Coach is an independent, open-source project and is not made by, endorsed by, or affiliated with Anthropic, PBC. "Claude" is a trademark of Anthropic. This tool is a skill/plugin that works with Claude products but is developed and maintained independently. 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,530 @@
+import { configExists, loadConfig, promptForConfig, saveConfig, saveTokens, getDbPath, createConfig, } from "./lib/config.js";
+import { log } from "./lib/logging.js";
+import { migrate } from "./db/migrate.js";
+import { execute, initDatabase, query, queryJson } from "./db/client.js";
+import { getValidTokens } from "./strava/oauth.js";
+import { getAllActivities, getAthlete } from "./strava/api.js";
+import { insertAthlete, upsertSummaryActivity } from "./strava/store.js";
+import { syncActivityDetails } from "./strava/details.js";
+import { convertPlan } from "./garmin/index.js";
+import { readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { ProxyAgent, setGlobalDispatcher } from "undici";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// ============================================================================
+// Proxy Configuration
+// ============================================================================
+// Configure proxy for fetch() if HTTP_PROXY or HTTPS_PROXY is set
+const proxyUrl = process.env.HTTPS_PROXY ||
+    process.env.https_proxy ||
+    process.env.HTTP_PROXY ||
+    process.env.http_proxy;
+if (proxyUrl) {
+    setGlobalDispatcher(new ProxyAgent(proxyUrl));
+}
+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("--access-token=")) {
+                syncArgs.accessToken = arg.split("=")[1];
+            }
+            else if (arg.startsWith("--refresh-token=")) {
+                syncArgs.refreshToken = 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] === "export-garmin") {
+        if (!args[1]) {
+            log.error("export-garmin command requires an input plan JSON file");
+            process.exit(1);
+        }
+        const exportArgs = {
+            command: "export-garmin",
+            inputFile: args[1],
+        };
+        for (let i = 2; i < args.length; i++) {
+            if (args[i] === "--output" || args[i] === "-o") {
+                exportArgs.outputFile = args[i + 1];
+                i++;
+            }
+            else if (args[i].startsWith("--output=")) {
+                exportArgs.outputFile = args[i].slice("--output=".length);
+            }
+            else if (args[i].startsWith("--tag=")) {
+                exportArgs.tag = args[i].slice("--tag=".length);
+            }
+            else if (args[i].startsWith("--workout=")) {
+                exportArgs.workoutId = args[i].slice("--workout=".length);
+            }
+            else if (args[i].startsWith("--date=")) {
+                exportArgs.date = args[i].slice("--date=".length);
+            }
+        }
+        return exportArgs;
+    }
+    if (args[0] === "query") {
+        if (!args[1]) {
+            log.error("query command requires a SQL statement");
+            process.exit(1);
+        }
+        const queryArgs = {
+            command: "query",
+            sql: args[1],
+            json: args.includes("--json"),
+        };
+        return queryArgs;
+    }
+    if (args[0] === "auth") {
+        const authArgs = { command: "auth" };
+        for (const arg of args) {
+            if (arg.startsWith("--client-id=")) {
+                authArgs.clientId = arg.slice("--client-id=".length);
+            }
+            else if (arg.startsWith("--client-secret=")) {
+                authArgs.clientSecret = arg.slice("--client-secret=".length);
+            }
+            else if (arg.startsWith("--code=")) {
+                authArgs.code = arg.slice("--code=".length);
+            }
+        }
+        return authArgs;
+    }
+    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 @robinthues/rt-claude-coach <command> [options]
+
+Commands:
+  sync              Sync activities from Strava
+  auth              Get Strava authorization URL or exchange code for tokens
+  render <file>     Render a training plan JSON to HTML
+  export-garmin <file>  Convert a plan JSON to Garmin sync workouts
+  query <sql>       Run a SQL query against the database
+  help              Show this help message
+
+Auth Options (for headless/Claude environments):
+  --client-id=ID        Strava API client ID
+  --client-secret=SEC   Strava API client secret
+  --code=URL_OR_CODE    Full redirect URL or just the authorization code
+
+  Step 1: Run 'auth' with credentials to get authorization URL
+  Step 2: User clicks URL, authorizes, copies entire redirect URL
+  Step 3: Run 'auth --code=URL' to exchange for tokens
+  Step 4: Run 'sync' to fetch activities
+
+Sync Options:
+  --client-id=ID        Strava API client ID (for OAuth flow)
+  --client-secret=SEC   Strava API client secret (for OAuth flow)
+  --days=N              Days of history to sync (default: 730)
+
+Render Options:
+  --output, -o FILE     Output HTML file (default: <input>.html)
+
+Export Garmin Options:
+  --output, -o FILE     Output JSON file (default: <input>-garmin-sync.json)
+  --tag=TAG             Plan tag for workout names/idempotency (default: derived)
+  --workout=ID          Export only the workout with this id
+  --date=YYYY-MM-DD     Export only workouts on this date
+
+Query Options:
+  --json                Output as JSON (default: plain text)
+
+Examples:
+  # Headless auth flow (for Claude/automated environments)
+  npx @robinthues/rt-claude-coach auth --client-id=12345 --client-secret=abc123
+  # User clicks URL, copies code from failed redirect
+  npx @robinthues/rt-claude-coach auth --code=AUTHORIZATION_CODE
+  npx @robinthues/rt-claude-coach sync
+
+  # Interactive auth flow (opens browser)
+  npx @robinthues/rt-claude-coach sync --client-id=12345 --client-secret=abc123
+
+  # Render a training plan to HTML
+  npx @robinthues/rt-claude-coach render plan.json --output my-plan.html
+
+  # Convert a whole plan to Garmin sync workouts
+  npx @robinthues/rt-claude-coach export-garmin plan.json --output garmin-sync.json
+
+  # Convert a single workout, or one day
+  npx @robinthues/rt-claude-coach export-garmin plan.json --workout=w1-tue-run
+  npx @robinthues/rt-claude-coach export-garmin plan.json --date=2026-09-15
+
+  # Query the database
+  npx @robinthues/rt-claude-coach query "SELECT * FROM weekly_volume LIMIT 5"
+`);
+}
+// ============================================================================
+// Auth Command (for headless/Claude environments)
+// ============================================================================
+const REDIRECT_PORT = 8765;
+const REDIRECT_URI = `http://localhost:${REDIRECT_PORT}/callback`;
+const AUTHORIZE_URL = "https://www.strava.com/oauth/authorize";
+const TOKEN_URL = "https://www.strava.com/oauth/token";
+async function runAuth(args) {
+    // If code is provided, exchange it for tokens
+    if (args.code) {
+        if (!configExists()) {
+            log.error("No configuration found. Run 'auth' with --client-id and --client-secret first.");
+            process.exit(1);
+        }
+        // Extract code from full URL if user pasted the entire redirect URL
+        let code = args.code;
+        if (code.includes("localhost") || code.startsWith("http")) {
+            try {
+                const url = new URL(code);
+                const extractedCode = url.searchParams.get("code");
+                if (extractedCode) {
+                    code = extractedCode;
+                }
+                else {
+                    log.error("Could not find 'code' parameter in URL");
+                    process.exit(1);
+                }
+            }
+            catch {
+                // Not a valid URL, use as-is
+            }
+        }
+        const config = loadConfig();
+        log.start("Exchanging authorization code for tokens...");
+        const tokenResponse = await fetch(TOKEN_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                client_id: config.strava.client_id,
+                client_secret: config.strava.client_secret,
+                code: code,
+                grant_type: "authorization_code",
+            }),
+        });
+        if (!tokenResponse.ok) {
+            const error = await tokenResponse.text();
+            log.error(`Token exchange failed: ${error}`);
+            process.exit(1);
+        }
+        const data = await tokenResponse.json();
+        const tokens = {
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            expires_at: data.expires_at,
+            athlete_id: data.athlete.id,
+        };
+        saveTokens(tokens);
+        log.success(`Authenticated as ${data.athlete.firstname} ${data.athlete.lastname}`);
+        log.ready("Now run: npx @robinthues/rt-claude-coach sync");
+        return;
+    }
+    // Otherwise, generate and print the authorization URL
+    if (!args.clientId || !args.clientSecret) {
+        log.error("Required: --client-id and --client-secret");
+        log.info("Get these from: https://www.strava.com/settings/api");
+        process.exit(1);
+    }
+    // Save config for later use
+    const config = createConfig(args.clientId, args.clientSecret, 730);
+    saveConfig(config);
+    const authUrl = new URL(AUTHORIZE_URL);
+    authUrl.searchParams.set("client_id", args.clientId);
+    authUrl.searchParams.set("response_type", "code");
+    authUrl.searchParams.set("redirect_uri", REDIRECT_URI);
+    authUrl.searchParams.set("scope", "activity:read_all");
+    authUrl.searchParams.set("approval_prompt", "auto");
+    console.log("\n📋 AUTHORIZATION URL:\n");
+    console.log(authUrl.toString());
+    console.log("\n📝 INSTRUCTIONS:");
+    console.log("1. Open the URL above in a browser");
+    console.log("2. Click 'Authorize' on Strava");
+    console.log("3. You'll be redirected to a page that won't load (that's OK!)");
+    console.log("4. Copy the ENTIRE URL from your browser's address bar");
+    console.log("5. Paste it back to Claude\n");
+}
+// ============================================================================
+// Sync Command
+// ============================================================================
+async function storeActivitiesAndDetails(tokens, activities) {
+    log.start("Storing activities in database...");
+    let count = 0;
+    for (const activity of activities) {
+        upsertSummaryActivity(activity);
+        count++;
+        if (count % 50 === 0) {
+            log.progress(`   Stored ${count}/${activities.length}...`);
+        }
+    }
+    log.progressEnd();
+    log.success(`Stored ${activities.length} activities`);
+    const details = await syncActivityDetails(tokens);
+    const status = details.stopped === "complete" ? "success" : "partial";
+    execute(`
+    INSERT INTO sync_log (started_at, completed_at, activities_synced, details_synced, status)
+    VALUES (datetime('now'), datetime('now'), ${activities.length}, ${details.fetched}, '${status}');
+  `);
+    log.info(`Database: ${getDbPath()}`);
+    if (status === "partial") {
+        log.ready("Sync stored all activities; detail backfill resumes on the next sync.");
+    }
+    else {
+        log.ready("Sync complete! You can now create training plans.");
+    }
+}
+async function runSync(args) {
+    log.box("Claude Coach - Strava Sync");
+    // Step 0: Initialize SQLite backend
+    await initDatabase();
+    const syncDays = args.days || 730;
+    // Step 1: Handle token-based auth (no browser needed)
+    if (args.accessToken && args.refreshToken) {
+        log.info("Using provided access tokens...");
+        // Save tokens - we'll get athlete_id after fetching profile
+        // Set expiry to 1 hour from now (we have refresh token for renewal)
+        const tempTokens = {
+            access_token: args.accessToken,
+            refresh_token: args.refreshToken,
+            expires_at: Math.floor(Date.now() / 1000) + 3600,
+            athlete_id: 0, // Will be updated after fetching athlete
+        };
+        saveTokens(tempTokens);
+        // Create minimal config if needed
+        if (!configExists()) {
+            // Token-based auth doesn't need client credentials for initial sync
+            // but we need them for token refresh - use placeholders
+            const config = createConfig("token-auth", "token-auth", syncDays);
+            saveConfig(config);
+        }
+        // Initialize database
+        migrate();
+        // Fetch athlete to get ID and validate tokens
+        log.start("Validating tokens and fetching athlete profile...");
+        const athlete = await getAthlete(tempTokens);
+        // Update tokens with real athlete ID
+        const tokens = { ...tempTokens, athlete_id: athlete.id };
+        saveTokens(tokens);
+        insertAthlete(athlete);
+        log.success(`Authenticated as ${athlete.firstname} ${athlete.lastname}`);
+        // Fetch activities
+        const afterDate = new Date();
+        afterDate.setDate(afterDate.getDate() - syncDays);
+        const activities = await getAllActivities(tokens, afterDate);
+        await storeActivitiesAndDetails(tokens, activities);
+        return;
+    }
+    // Step 2: OAuth-based auth (requires browser)
+    if (!configExists()) {
+        if (args.clientId && args.clientSecret) {
+            log.info("Creating configuration from command line arguments...");
+            const config = createConfig(args.clientId, args.clientSecret, syncDays);
+            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 configSyncDays = args.days || config.sync_days || 730;
+    // Initialize database
+    migrate();
+    // Authenticate with Strava (opens browser)
+    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() - configSyncDays);
+    const activities = await getAllActivities(tokens, afterDate);
+    await storeActivitiesAndDetails(tokens, activities);
+    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);
+    }
+}
+// ============================================================================
+// Export Garmin Command
+// ============================================================================
+function runExportGarmin(args) {
+    log.start("Converting plan to Garmin workouts...");
+    let planJson;
+    try {
+        planJson = readFileSync(args.inputFile, "utf-8");
+    }
+    catch {
+        log.error(`Could not read input file: ${args.inputFile}`);
+        process.exit(1);
+    }
+    let plan;
+    try {
+        plan = JSON.parse(planJson);
+    }
+    catch {
+        log.error("Input file is not valid JSON");
+        process.exit(1);
+    }
+    const filter = {};
+    if (args.workoutId !== undefined)
+        filter.workoutId = args.workoutId;
+    if (args.date !== undefined)
+        filter.date = args.date;
+    const hasFilter = filter.workoutId !== undefined || filter.date !== undefined;
+    let entries;
+    try {
+        entries = convertPlan(plan, {
+            tag: args.tag,
+            filter: hasFilter ? filter : undefined,
+        });
+    }
+    catch (err) {
+        log.error(`Conversion failed: ${err.message}`);
+        process.exit(1);
+    }
+    const outputFile = args.outputFile ??
+        (args.inputFile.endsWith(".json")
+            ? args.inputFile.replace(/\.json$/, "-garmin-sync.json")
+            : `${args.inputFile}-garmin-sync.json`);
+    writeFileSync(outputFile, JSON.stringify(entries, null, 2));
+    log.success(`Wrote ${entries.length} Garmin workout entries to: ${outputFile}`);
+}
+// ============================================================================
+// Query Command
+// ============================================================================
+async function runQuery(args) {
+    await initDatabase();
+    if (args.json) {
+        const results = queryJson(args.sql);
+        console.log(JSON.stringify(results, null, 2));
+    }
+    else {
+        const result = query(args.sql);
+        console.log(result);
+    }
+}
+// ============================================================================
+// Main
+// ============================================================================
+async function main() {
+    const args = parseArgs();
+    switch (args.command) {
+        case "help":
+            printHelp();
+            break;
+        case "auth":
+            await runAuth(args);
+            break;
+        case "sync":
+            await runSync(args);
+            break;
+        case "render":
+            runRender(args);
+            break;
+        case "export-garmin":
+            runExportGarmin(args);
+            break;
+        case "query":
+            await runQuery(args);
+            break;
+    }
+}
+main().catch((err) => {
+    log.error(err.message);
+    process.exit(1);
+});

package/dist/db/client.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Initialize the SQLite backend. Must be called before using other functions.
+ */
+export declare function initDatabase(): Promise<void>;
+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;