@robinthues/rt-claude-coach 0.2.0 → 0.3.0

package/dist/backup/restore.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Rebuild a database from `schemaSql` plus a dump produced by `dumpDatabase`.
+ *
+ * Refuses to touch an existing file: restoring over live data would be the
+ * exact accident this whole feature exists to protect against.
+ *
+ * A restore happens once every few years, at the worst possible moment: the
+ * original machine is gone and the user is rebuilding from nothing. If schema
+ * creation or dump replay fails partway through, we must not leave a partial
+ * file behind — a half-built database at `dbPath` would make the *next*
+ * attempt fail with "already exists" and send the user hunting for data they
+ * never had, instead of just letting them retry. So on any failure after the
+ * file is created, we close it, delete it (this call is the only thing that
+ * could have created it, since the existsSync guard above already refused to
+ * run otherwise), and rethrow the original error — never a cleanup error.
+ */
+export declare function restoreDatabase(dbPath: string, dumpSql: string, schemaSql: string): void;
+/**
+ * Move `dbPath` to `<dbPath>.bak`, replacing an older .bak, and return the
+ * new path. Its journal and WAL files move with it under the matching .bak
+ * names: left behind, SQLite could apply a stale journal to the restored
+ * database, while next to the .bak it still belongs to the data it came
+ * from. Sidecars of the older .bak are removed so they cannot be applied to
+ * the wrong file.
+ */
+export declare function moveAsideDatabase(dbPath: string): string;
+/** The `restore-db` command. Returns the process exit code. */
+export declare function runRestore(options: {
+    dbPath: string;
+    dumpPath: string;
+    schemaPath: string;
+    force: boolean;
+}): number;

package/dist/backup/restore.js

@@ -0,0 +1,102 @@
+import { DatabaseSync } from "node:sqlite";
+import { existsSync, readFileSync, renameSync, rmSync, unlinkSync } from "fs";
+import { log } from "../lib/logging.js";
+/**
+ * Rebuild a database from `schemaSql` plus a dump produced by `dumpDatabase`.
+ *
+ * Refuses to touch an existing file: restoring over live data would be the
+ * exact accident this whole feature exists to protect against.
+ *
+ * A restore happens once every few years, at the worst possible moment: the
+ * original machine is gone and the user is rebuilding from nothing. If schema
+ * creation or dump replay fails partway through, we must not leave a partial
+ * file behind — a half-built database at `dbPath` would make the *next*
+ * attempt fail with "already exists" and send the user hunting for data they
+ * never had, instead of just letting them retry. So on any failure after the
+ * file is created, we close it, delete it (this call is the only thing that
+ * could have created it, since the existsSync guard above already refused to
+ * run otherwise), and rethrow the original error — never a cleanup error.
+ */
+export function restoreDatabase(dbPath, dumpSql, schemaSql) {
+    if (existsSync(dbPath)) {
+        throw new Error(`${dbPath} already exists. Move it aside or pass --force.`);
+    }
+    const db = new DatabaseSync(dbPath);
+    try {
+        db.exec(schemaSql);
+        db.exec("BEGIN");
+        try {
+            if (dumpSql.trim().length > 0)
+                db.exec(dumpSql);
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    catch (error) {
+        try {
+            db.close();
+        }
+        catch {
+            // Original error is what the caller needs to see; ignore close failures here.
+        }
+        try {
+            unlinkSync(dbPath);
+        }
+        catch {
+            // Original error still takes priority over any cleanup failure.
+        }
+        throw error;
+    }
+    db.close();
+}
+/** Files SQLite keeps next to a database, named `<db>-journal` and so on. */
+const SIDECARS = ["-journal", "-wal", "-shm"];
+/**
+ * Move `dbPath` to `<dbPath>.bak`, replacing an older .bak, and return the
+ * new path. Its journal and WAL files move with it under the matching .bak
+ * names: left behind, SQLite could apply a stale journal to the restored
+ * database, while next to the .bak it still belongs to the data it came
+ * from. Sidecars of the older .bak are removed so they cannot be applied to
+ * the wrong file.
+ */
+export function moveAsideDatabase(dbPath) {
+    const bakPath = `${dbPath}.bak`;
+    for (const suffix of SIDECARS)
+        rmSync(`${bakPath}${suffix}`, { force: true });
+    renameSync(dbPath, bakPath);
+    for (const suffix of SIDECARS) {
+        if (existsSync(`${dbPath}${suffix}`))
+            renameSync(`${dbPath}${suffix}`, `${bakPath}${suffix}`);
+    }
+    return bakPath;
+}
+/** The `restore-db` command. Returns the process exit code. */
+export function runRestore(options) {
+    const { dbPath, dumpPath, schemaPath } = options;
+    if (!existsSync(dumpPath)) {
+        log.error(`No dump at ${dumpPath}`);
+        return 1;
+    }
+    if (existsSync(dbPath)) {
+        if (!options.force) {
+            log.error(`${dbPath} already exists. Move it aside or pass --force.`);
+            return 1;
+        }
+    }
+    const backupPath = existsSync(dbPath) ? moveAsideDatabase(dbPath) : undefined;
+    if (backupPath)
+        log.info(`Moved the existing database to ${backupPath}`);
+    try {
+        restoreDatabase(dbPath, readFileSync(dumpPath, "utf-8"), readFileSync(schemaPath, "utf-8"));
+    }
+    catch (error) {
+        const kept = backupPath ? ` Your previous database is at ${backupPath}.` : "";
+        log.error(`Restore failed: ${error.message}.${kept}`);
+        return 1;
+    }
+    log.success(`Restored ${dbPath} from ${dumpPath}`);
+    return 0;
+}

package/dist/cli.d.ts

@@ -1 +1,10 @@
+interface BackupArgs {
+    command: "backup";
+    init: boolean;
+    push: boolean;
+    quiet: boolean;
+    repo: string;
+}
+export declare const DEFAULT_BACKUP_REPO = "RobinThues/claude-coach-data";
+export declare function parseBackupArgs(args: string[]): BackupArgs;
 export {};

package/dist/cli.js

@@ -1,4 +1,4 @@
-import { configExists, loadConfig, promptForConfig, saveConfig, saveTokens, getDbPath, createConfig, } from "./lib/config.js";
+import { configExists, loadConfig, promptForConfig, saveConfig, saveTokens, getDbPath, getDataDir, 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";
@@ -9,6 +9,8 @@ import { syncActivityDetails } from "./strava/details.js";
 import { convertPlan } from "./garmin/index.js";
 import { buildFetchList, getDateStatuses, lastNDates, parseRecoveryDay, upsertRecoveryDay, } from "./recovery/index.js";
 import { buildAvailability, isIsoDate } from "./calendar/index.js";
+import { runBackup, runInit } from "./backup/index.js";
+import { runRestore } from "./backup/restore.js";
 import { readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
@@ -25,6 +27,27 @@ const proxyUrl = process.env.HTTPS_PROXY ||
 if (proxyUrl) {
     setGlobalDispatcher(new ProxyAgent(proxyUrl));
 }
+export const DEFAULT_BACKUP_REPO = "RobinThues/claude-coach-data";
+export function parseBackupArgs(args) {
+    const parsed = {
+        command: "backup",
+        init: false,
+        push: true,
+        quiet: false,
+        repo: DEFAULT_BACKUP_REPO,
+    };
+    for (const arg of args.slice(1)) {
+        if (arg === "--init")
+            parsed.init = true;
+        else if (arg === "--no-push")
+            parsed.push = false;
+        else if (arg === "--quiet")
+            parsed.quiet = true;
+        else if (arg.startsWith("--repo="))
+            parsed.repo = arg.slice("--repo=".length);
+    }
+    return parsed;
+}
 function parseArgs() {
     const args = process.argv.slice(2);
     if (args.length === 0 || args[0] === "sync") {
@@ -161,6 +184,19 @@ function parseArgs() {
         }
         return authArgs;
     }
+    if (args[0] === "backup") {
+        return parseBackupArgs(args);
+    }
+    if (args[0] === "restore-db") {
+        const parsed = { command: "restore-db", force: false };
+        for (const arg of args.slice(1)) {
+            if (arg === "--force")
+                parsed.force = true;
+            else if (arg.startsWith("--dump="))
+                parsed.dumpFile = arg.slice("--dump=".length);
+        }
+        return parsed;
+    }
     if (args[0] === "--help" || args[0] === "-h" || args[0] === "help") {
         return { command: "help" };
     }
@@ -182,6 +218,8 @@ Commands:
   import-garmin <file>  Import Garmin recovery MCP responses into the database
   calendar-availability <file>  Normalize calendar MCP events into per-day busy blocks
   query <sql>       Run a SQL query against the database
+  backup            Commit the coach data directory and push it to the backup repo
+  restore-db        Rebuild coach.db from backup/coach-db.sql
   help              Show this help message
 
 Auth Options (for headless/Claude environments):
@@ -218,6 +256,16 @@ Calendar Availability Options:
 Query Options:
   --json                Output as JSON (default: plain text)
 
+Backup Options:
+  --init                One-time setup: git init, .gitignore, RESTORE.md, remote
+  --no-push             Commit locally without pushing
+  --quiet               Suppress non-error output (used by the Claude Code hook)
+  --repo=OWNER/NAME     Override the backup repo (default: RobinThues/claude-coach-data)
+
+Restore Options:
+  --dump=PATH           Read the dump from PATH instead of backup/coach-db.sql
+  --force               Move an existing coach.db to coach.db.bak, then restore
+
 Examples:
   # Headless auth flow (for Claude/automated environments)
   npx @robinthues/rt-claude-coach auth --client-id=12345 --client-secret=abc123
@@ -678,6 +726,24 @@ async function runQuery(args) {
     }
 }
 // ============================================================================
+// Backup / Restore Commands
+// ============================================================================
+async function runBackupCommand(args) {
+    const code = args.init
+        ? await runInit({ repo: args.repo, quiet: args.quiet })
+        : await runBackup({ push: args.push, quiet: args.quiet });
+    process.exit(code);
+}
+function runRestoreDb(args) {
+    const code = runRestore({
+        dbPath: getDbPath(),
+        dumpPath: args.dumpFile ?? join(getDataDir(), "backup", "coach-db.sql"),
+        schemaPath: join(__dirname, "db", "schema.sql"),
+        force: args.force,
+    });
+    process.exit(code);
+}
+// ============================================================================
 // Main
 // ============================================================================
 async function main() {
@@ -710,9 +776,22 @@ async function main() {
         case "query":
             await runQuery(args);
             break;
+        case "backup":
+            await runBackupCommand(args);
+            break;
+        case "restore-db":
+            runRestoreDb(args);
+            break;
     }
 }
-main().catch((err) => {
-    log.error(err.message);
-    process.exit(1);
-});
+// Vitest sets VITEST=true in every test process. Importing this module for
+// its exported parsers (parseBackupArgs, etc.) must not also run the CLI
+// against the real environment, so skip main() there. Real invocations
+// (tsx src/cli.ts, or bin/claude-coach.js dynamically importing dist/cli.js)
+// never set this variable.
+if (process.env.VITEST !== "true") {
+    main().catch((err) => {
+        log.error(err.message);
+        process.exit(1);
+    });
+}

package/dist/db/client.js

@@ -12,6 +12,10 @@ async function detectBackend() {
         const sqlite = await import("node:sqlite");
         const dbPath = getDbPath();
         const db = new sqlite.DatabaseSync(dbPath);
+        // A backup dump holds a read-only connection open on this same file. A
+        // coach write during that window would otherwise fail at once with
+        // "database is locked" instead of just waiting the dump out.
+        db.exec("PRAGMA busy_timeout = 5000");
         return {
             query(sql) {
                 const stmt = db.prepare(sql);

package/dist/lib/config.d.ts

@@ -1,3 +1,4 @@
+export declare function getDataDir(): string;
 export interface StravaConfig {
     client_id: string;
     client_secret: string;

package/dist/lib/config.js

@@ -2,51 +2,57 @@ 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 getDataDir() {
+    return process.env.CLAUDE_COACH_DIR ?? join(homedir(), ".claude-coach");
+}
+function configFile() {
+    return join(getDataDir(), "config.json");
+}
+function tokensFile() {
+    return join(getDataDir(), "tokens.json");
+}
 export function ensureConfigDir() {
-    if (!existsSync(CONFIG_DIR)) {
-        mkdirSync(CONFIG_DIR, { recursive: true });
+    const dataDir = getDataDir();
+    if (!existsSync(dataDir)) {
+        mkdirSync(dataDir, { recursive: true });
     }
 }
 export function getConfigPath() {
-    return CONFIG_FILE;
+    return configFile();
 }
 export function getTokensPath() {
-    return TOKENS_FILE;
+    return tokensFile();
 }
 export function getDbPath() {
-    return process.env.CLAUDE_COACH_DB ?? DB_FILE;
+    return process.env.CLAUDE_COACH_DB ?? join(getDataDir(), "coach.db");
 }
 export function configExists() {
-    return existsSync(CONFIG_FILE);
+    return existsSync(configFile());
 }
 export function tokensExist() {
-    return existsSync(TOKENS_FILE);
+    return existsSync(tokensFile());
 }
 export function loadConfig() {
     if (!configExists()) {
-        throw new Error(`Config not found at ${CONFIG_FILE}. Run setup first.`);
+        throw new Error(`Config not found at ${configFile()}. Run setup first.`);
     }
-    const data = readFileSync(CONFIG_FILE, "utf-8");
+    const data = readFileSync(configFile(), "utf-8");
     return JSON.parse(data);
 }
 export function saveConfig(config) {
     ensureConfigDir();
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+    writeFileSync(configFile(), JSON.stringify(config, null, 2));
 }
 export function loadTokens() {
     if (!tokensExist()) {
-        throw new Error(`Tokens not found at ${TOKENS_FILE}. Run auth first.`);
+        throw new Error(`Tokens not found at ${tokensFile()}. Run auth first.`);
     }
-    const data = readFileSync(TOKENS_FILE, "utf-8");
+    const data = readFileSync(tokensFile(), "utf-8");
     return JSON.parse(data);
 }
 export function saveTokens(tokens) {
     ensureConfigDir();
-    writeFileSync(TOKENS_FILE, JSON.stringify(tokens, null, 2));
+    writeFileSync(tokensFile(), JSON.stringify(tokens, null, 2));
 }
 export function tokensExpired(tokens) {
     // Add 60 second buffer

package/dist/viewer/lib/completion.d.ts

@@ -0,0 +1,5 @@
+import type { TrainingPlan } from "../../schema/training-plan.js";
+/**
+ * Build the viewer's completion map from the plan's own `completed` flags.
+ */
+export declare function completedFromPlan(plan: TrainingPlan): Record<string, boolean>;

package/dist/viewer/lib/completion.js

@@ -0,0 +1,15 @@
+/**
+ * Build the viewer's completion map from the plan's own `completed` flags.
+ */
+export function completedFromPlan(plan) {
+    const completed = {};
+    plan.weeks?.forEach((week) => {
+        week.days?.forEach((day) => {
+            day.workouts?.forEach((workout) => {
+                if (workout.completed)
+                    completed[workout.id] = true;
+            });
+        });
+    });
+    return completed;
+}

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

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

package/dist/viewer/stores/plan.js

@@ -1,3 +1,4 @@
+import { completedFromPlan } from "../lib/completion.js";
 // Load plan from embedded JSON
 function loadPlanData() {
     const el = document.getElementById("plan-data");
@@ -8,12 +9,10 @@ function loadPlanData() {
 // Reactive state using Svelte 5's $state rune is only available in .svelte files
 // So we export the raw data and let components create reactive state
 export const planData = loadPlanData();
-// Completed workouts stored in localStorage
-const storageKey = `plan-${planData.meta.id}-completed`;
+// Completion is owned by plan.json — the coach records it there from synced
+// activity data. The viewer reads it and never writes it back: a tick stored
+// only in this browser would be a second source of truth that the next render
+// silently overwrites.
 export function loadCompleted() {
-    const saved = localStorage.getItem(storageKey);
-    return saved ? JSON.parse(saved) : {};
-}
-export function saveCompleted(completed) {
-    localStorage.setItem(storageKey, JSON.stringify(completed));
+    return completedFromPlan(planData);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robinthues/rt-claude-coach",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "author": "Robin Thues",
   "license": "MIT",
   "repository": {