endurance-coach 0.1.0

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;

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 @@
+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/db/schema.sql

@@ -0,0 +1,105 @@
+-- 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,
+  workout_type INTEGER,             -- 0=default, 1=race, 2=workout, 3=long run
+  gear_id TEXT,
+  raw_json TEXT,                    -- full Strava response as JSON
+  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,
+  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/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Endurance Coach - Training Plan Generator
+ *
+ * Public API for validating and working with training plans.
+ */
+export { validatePlan, validatePlanOrThrow, formatValidationErrors, getJsonSchema, TrainingPlanSchema, WorkoutSchema, TrainingWeekSchema, TrainingDaySchema, TrainingPhaseSchema, AthleteAssessmentSchema, AthleteZonesSchema, RaceStrategySchema, UnitPreferencesSchema, PlanMetaSchema, type TrainingPlan, type Workout, type TrainingWeek, type TrainingDay, type TrainingPhase, type AthleteAssessment, type AthleteZones, type RaceStrategy, type UnitPreferences, type ValidationResult, type ValidationError, } from "./schema/training-plan.schema.js";
+export type { Sport, WorkoutType, IntensityUnit, DurationUnit, StepType, SwimDistanceUnit, LandDistanceUnit, FirstDayOfWeek, IntensityTarget, DurationTarget, WorkoutStep, IntervalSet, StructuredWorkout, WeekSummary, HeartRateZones, PowerZones, SwimZones, PaceZones, } from "./schema/training-plan.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * Endurance Coach - Training Plan Generator
+ *
+ * Public API for validating and working with training plans.
+ */
+// Schema validation
+export { 
+// Validation functions
+validatePlan, validatePlanOrThrow, formatValidationErrors, getJsonSchema, 
+// Main schema
+TrainingPlanSchema, 
+// Component schemas (for partial validation)
+WorkoutSchema, TrainingWeekSchema, TrainingDaySchema, TrainingPhaseSchema, AthleteAssessmentSchema, AthleteZonesSchema, RaceStrategySchema, UnitPreferencesSchema, PlanMetaSchema, } from "./schema/training-plan.schema.js";

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(), ".endurance-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🚴 Endurance 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");
+    },
+};