@robinthues/rt-claude-coach 0.1.2 → 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/calendar/dates.d.ts

@@ -0,0 +1,24 @@
+import type { RawEvent } from "./types.js";
+/** True when an event is all-day (uses `date`, not `dateTime`). */
+export declare function isAllDay(event: RawEvent): boolean;
+/** The YYYY-MM-DD portion of an all-day time value. */
+export declare function allDayDate(value: string): string;
+/** Advance a YYYY-MM-DD string by one day, UTC-safe (no DST drift). */
+export declare function addDay(date: string): string;
+/** True when a string is a YYYY-MM-DD calendar date. */
+export declare function isIsoDate(value: string): boolean;
+/** Enumerate dates from start (inclusive) to end (exclusive). */
+export declare function datesInRange(startInclusive: string, endExclusive: string): string[];
+/** The weekday name for a YYYY-MM-DD date. */
+export declare function weekdayOf(date: string): string;
+/**
+ * Some ICU builds render midnight on a 24-hour clock as "24"; normalise it to
+ * "00" so a wall-clock hour is always in [00, 23]. Defensive against ICU
+ * variation across Node runtimes — inert where the clock is already h23.
+ */
+export declare function normalizeHour(hour: string): string;
+/** Resolve an RFC3339 timed value to wall-clock date + HH:MM in the target zone. */
+export declare function resolveWallClock(dateTime: string, timeZone: string): {
+    date: string;
+    time: string;
+};

package/dist/calendar/dates.js

@@ -0,0 +1,57 @@
+/** True when an event is all-day (uses `date`, not `dateTime`). */
+export function isAllDay(event) {
+    return Boolean(event.start?.date) && !event.start?.dateTime;
+}
+/** The YYYY-MM-DD portion of an all-day time value. */
+export function allDayDate(value) {
+    return value.slice(0, 10);
+}
+/** Advance a YYYY-MM-DD string by one day, UTC-safe (no DST drift). */
+export function addDay(date) {
+    const [y, m, d] = date.split("-").map(Number);
+    return new Date(Date.UTC(y, m - 1, d + 1)).toISOString().slice(0, 10);
+}
+/** True when a string is a YYYY-MM-DD calendar date. */
+export function isIsoDate(value) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+/** Enumerate dates from start (inclusive) to end (exclusive). */
+export function datesInRange(startInclusive, endExclusive) {
+    const out = [];
+    let cur = startInclusive;
+    while (cur < endExclusive) {
+        out.push(cur);
+        cur = addDay(cur);
+    }
+    return out;
+}
+const WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+/** The weekday name for a YYYY-MM-DD date. */
+export function weekdayOf(date) {
+    const [y, m, d] = date.split("-").map(Number);
+    return WEEKDAYS[new Date(Date.UTC(y, m - 1, d)).getUTCDay()];
+}
+/**
+ * Some ICU builds render midnight on a 24-hour clock as "24"; normalise it to
+ * "00" so a wall-clock hour is always in [00, 23]. Defensive against ICU
+ * variation across Node runtimes — inert where the clock is already h23.
+ */
+export function normalizeHour(hour) {
+    return hour === "24" ? "00" : hour;
+}
+/** Resolve an RFC3339 timed value to wall-clock date + HH:MM in the target zone. */
+export function resolveWallClock(dateTime, timeZone) {
+    const dt = new Date(dateTime);
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    }).formatToParts(dt);
+    const get = (type) => parts.find((p) => p.type === type).value;
+    const hour = normalizeHour(get("hour"));
+    return { date: `${get("year")}-${get("month")}-${get("day")}`, time: `${hour}:${get("minute")}` };
+}

package/dist/calendar/index.d.ts

@@ -0,0 +1,3 @@
+export { isCancelled, isFree, isNonBlockingType, isDeclined, isBusy, eventTitle, buildAvailability, } from "./parse.js";
+export { isAllDay, allDayDate, addDay, isIsoDate, datesInRange, weekdayOf, resolveWallClock, } from "./dates.js";
+export type { RawEvent, RawEventTime, RawAttendee, CalendarEventsResponse, CalendarInput, AvailabilityInput, BusyBlock, AllDayEvent, DayAvailability, AvailabilityOutput, } from "./types.js";

package/dist/calendar/index.js

@@ -0,0 +1,2 @@
+export { isCancelled, isFree, isNonBlockingType, isDeclined, isBusy, eventTitle, buildAvailability, } from "./parse.js";
+export { isAllDay, allDayDate, addDay, isIsoDate, datesInRange, weekdayOf, resolveWallClock, } from "./dates.js";

package/dist/calendar/parse.d.ts

@@ -0,0 +1,19 @@
+import type { RawEvent, AvailabilityInput, AvailabilityOutput } from "./types.js";
+/** Google marks deleted/cancelled instances with status "cancelled". */
+export declare function isCancelled(e: RawEvent): boolean;
+/** The athlete set themselves free during this event, so it does not block training. */
+export declare function isFree(e: RawEvent): boolean;
+/** Event types that never represent a real time commitment. */
+export declare function isNonBlockingType(e: RawEvent): boolean;
+/** The athlete declined this invitation. */
+export declare function isDeclined(e: RawEvent): boolean;
+/** Whether this event should count against the athlete's availability. */
+export declare function isBusy(e: RawEvent): boolean;
+/** A display title, with a placeholder for untitled events. */
+export declare function eventTitle(e: RawEvent): string;
+/**
+ * Normalise verbatim `list_events` responses into a clean per-day picture of
+ * busy blocks and all-day events. Every date in the window appears, so a clear
+ * day reads as clear rather than missing. All-day `end` dates are exclusive.
+ */
+export declare function buildAvailability(input: AvailabilityInput): AvailabilityOutput;

package/dist/calendar/parse.js

@@ -0,0 +1,74 @@
+import { isAllDay, allDayDate, addDay, datesInRange, weekdayOf, resolveWallClock, } from "./dates.js";
+/** Google marks deleted/cancelled instances with status "cancelled". */
+export function isCancelled(e) {
+    return e.status === "cancelled";
+}
+/** The athlete set themselves free during this event, so it does not block training. */
+export function isFree(e) {
+    return e.transparency === "transparent" || e.availability === "AVAILABILITY_FREE";
+}
+const NON_BLOCKING_TYPES = new Set(["BIRTHDAY", "WORKING_LOCATION"]);
+/** Event types that never represent a real time commitment. */
+export function isNonBlockingType(e) {
+    return e.eventType !== undefined && NON_BLOCKING_TYPES.has(e.eventType);
+}
+/** The athlete declined this invitation. */
+export function isDeclined(e) {
+    const self = e.attendees?.find((a) => a.self);
+    return self?.responseStatus === "declined";
+}
+/** Whether this event should count against the athlete's availability. */
+export function isBusy(e) {
+    return !isCancelled(e) && !isFree(e) && !isNonBlockingType(e) && !isDeclined(e);
+}
+/** A display title, with a placeholder for untitled events. */
+export function eventTitle(e) {
+    const title = (e.summary ?? "").trim();
+    return title.length > 0 ? title : "(no title)";
+}
+/**
+ * Normalise verbatim `list_events` responses into a clean per-day picture of
+ * busy blocks and all-day events. Every date in the window appears, so a clear
+ * day reads as clear rather than missing. All-day `end` dates are exclusive.
+ */
+export function buildAvailability(input) {
+    const { timeZone, window } = input;
+    const days = new Map();
+    for (const date of datesInRange(window.start, window.end)) {
+        days.set(date, { date, weekday: weekdayOf(date), allDayEvents: [], busyBlocks: [] });
+    }
+    for (const cal of input.calendars) {
+        const events = cal.responses.flatMap((r) => r.events ?? []);
+        for (const event of events) {
+            if (!isBusy(event))
+                continue;
+            const title = eventTitle(event);
+            if (isAllDay(event)) {
+                const startDate = allDayDate(event.start.date);
+                const endExclusive = event.end?.date ? allDayDate(event.end.date) : addDay(startDate);
+                for (const date of datesInRange(startDate, endExclusive)) {
+                    days.get(date)?.allDayEvents.push({ title, calendar: cal.summary });
+                }
+                continue;
+            }
+            if (event.start?.dateTime && event.end?.dateTime) {
+                const start = resolveWallClock(event.start.dateTime, timeZone);
+                const end = resolveWallClock(event.end.dateTime, timeZone);
+                // A timed block is attributed to its start day; multi-day timed events are vanishingly rare.
+                days.get(start.date)?.busyBlocks.push({
+                    start: start.time,
+                    end: end.time,
+                    title,
+                    calendar: cal.summary,
+                });
+            }
+        }
+    }
+    for (const day of days.values()) {
+        day.busyBlocks.sort((a, b) => a.start.localeCompare(b.start) || a.end.localeCompare(b.end));
+    }
+    return {
+        window: { start: window.start, end: window.end, timeZone },
+        days: [...days.values()],
+    };
+}

package/dist/calendar/types.d.ts

@@ -0,0 +1,70 @@
+/** One time endpoint of a calendar event: all-day (`date`) or timed (`dateTime`). */
+export interface RawEventTime {
+    /** All-day marker, e.g. "2026-07-25T00:00:00Z" or "2026-07-25". */
+    date?: string;
+    /** Timed RFC3339 value with offset, e.g. "2026-08-04T18:00:00+02:00". */
+    dateTime?: string;
+    timeZone?: string;
+}
+export interface RawAttendee {
+    email?: string;
+    self?: boolean;
+    responseStatus?: string;
+}
+/** A single event from a `list_events` response. All fields optional. */
+export interface RawEvent {
+    summary?: string;
+    status?: string;
+    transparency?: string;
+    availability?: string;
+    eventType?: string;
+    start?: RawEventTime;
+    end?: RawEventTime;
+    attendees?: RawAttendee[];
+}
+/** One verbatim `list_events` page response. */
+export interface CalendarEventsResponse {
+    events?: RawEvent[];
+    summary?: string;
+    timeZone?: string;
+    nextPageToken?: string;
+}
+/** One selected calendar's verbatim page responses. */
+export interface CalendarInput {
+    summary: string;
+    responses: CalendarEventsResponse[];
+}
+/** The wrapper file the skill assembles and passes to the CLI. */
+export interface AvailabilityInput {
+    timeZone: string;
+    /** Window covered; `end` is exclusive, both YYYY-MM-DD. */
+    window: {
+        start: string;
+        end: string;
+    };
+    calendars: CalendarInput[];
+}
+export interface BusyBlock {
+    start: string;
+    end: string;
+    title: string;
+    calendar: string;
+}
+export interface AllDayEvent {
+    title: string;
+    calendar: string;
+}
+export interface DayAvailability {
+    date: string;
+    weekday: string;
+    allDayEvents: AllDayEvent[];
+    busyBlocks: BusyBlock[];
+}
+export interface AvailabilityOutput {
+    window: {
+        start: string;
+        end: string;
+        timeZone: string;
+    };
+    days: DayAvailability[];
+}

package/dist/calendar/types.js

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

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 {};