@richhaase/c2 0.3.3 → 0.4.0

package/src/commands/show.ts

@@ -0,0 +1,120 @@
+import type { Command } from "commander";
+import { splitShape, splitTable, strokeSummary } from "../analysis.ts";
+import { loadConfig } from "../config.ts";
+import { formatMeters, formatWorkoutLine, workoutJSON } from "../display.ts";
+import { printJSON } from "../envelope.ts";
+import type { Workout } from "../models.ts";
+import { formatSeconds } from "../models.ts";
+import { filterNotes, readAllNotes } from "../notes.ts";
+import { dataPaths } from "../paths.ts";
+import { readStrokeData, readWorkouts } from "../storage.ts";
+
+export function resolveWorkout(workouts: Workout[], ref: string): Workout | null {
+  if (ref === "last") {
+    if (workouts.length === 0) return null;
+    return workouts.reduce((latest, w) => (w.date > latest.date ? w : latest));
+  }
+  const id = Number(ref);
+  if (!Number.isInteger(id)) return null;
+  return workouts.find((w) => w.id === id) ?? null;
+}
+
+export function registerShow(program: Command): void {
+  program
+    .command("show <id>")
+    .description("Show full detail for one workout (use a workout id or 'last')")
+    .option("--json", "output as JSON")
+    .action(async (ref: string, opts: { json?: boolean }) => {
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const workouts = await readWorkouts(paths);
+      const w = resolveWorkout(workouts, ref);
+      if (w == null) {
+        console.error(
+          ref === "last"
+            ? "No workouts found. Run `c2 sync` first."
+            : `No workout with id ${ref}. Use \`c2 log --json\` to list ids.`,
+        );
+        process.exit(1);
+      }
+
+      const splits = splitTable(w);
+      const shape = splitShape(splits);
+      const strokes = await readStrokeData(paths, w.id);
+      const strokesSummary = strokes.length > 0 ? strokeSummary(strokes) : null;
+      const linkedNotes = filterNotes(await readAllNotes(paths), { workoutId: w.id });
+
+      if (opts.json) {
+        printJSON("c2.show.v1", {
+          workout: workoutJSON(w),
+          raw: w,
+          target_pace_500m_seconds: w.workout?.targets?.pace ? w.workout.targets.pace / 10 : null,
+          splits,
+          split_shape: shape,
+          stroke_summary: strokesSummary,
+          notes: linkedNotes,
+        });
+        return;
+      }
+
+      console.log(formatWorkoutLine(w, cfg.display.date_format));
+      console.log();
+      console.log(`Id: ${w.id}`);
+      console.log(`Date: ${w.date}${w.timezone ? ` (${w.timezone})` : ""}`);
+      if (w.workout_type) console.log(`Type: ${w.workout_type}`);
+      if (w.source) console.log(`Source: ${w.source}`);
+      if (w.stroke_count) console.log(`Strokes: ${formatMeters(w.stroke_count)}`);
+      if (w.calories_total) console.log(`Calories: ${w.calories_total}`);
+      if (w.heart_rate?.average) {
+        const hr = w.heart_rate;
+        const parts = [
+          hr.min != null ? `min ${hr.min}` : null,
+          `avg ${hr.average}`,
+          hr.max != null ? `max ${hr.max}` : null,
+          hr.ending != null ? `ending ${hr.ending}` : null,
+        ].filter(Boolean);
+        console.log(`Heart rate: ${parts.join(", ")}`);
+      }
+      if (w.rest_time != null && w.rest_time > 0) {
+        console.log(`Interval rest: ${formatSeconds(w.rest_time / 10)}`);
+      }
+      if (w.rest_distance != null && w.rest_distance > 0) {
+        console.log(`Interval rest distance: ${formatMeters(w.rest_distance)}m`);
+      }
+      if (w.workout?.targets?.pace) {
+        console.log(`Target pace: ${formatSeconds(w.workout.targets.pace / 10)}/500m`);
+      }
+      if (w.comments) console.log(`Comments: ${w.comments}`);
+
+      if (splits.length > 0) {
+        console.log();
+        console.log(`Splits (${shape}):`);
+        console.log("    #      dist      time     pace/500m   spm    hr");
+        for (const s of splits) {
+          const dist = s.distance != null ? `${formatMeters(s.distance)}m` : "-";
+          const pace = s.pace_500m ?? "-";
+          const spm = s.stroke_rate ?? "-";
+          const hr =
+            s.hr_avg != null ? `${s.hr_avg}${s.hr_max != null ? `/${s.hr_max}` : ""}` : "-";
+          console.log(
+            `  ${String(s.index).padStart(3)}  ${dist.padStart(8)}  ${formatSeconds(s.time_seconds).padStart(8)}  ${pace.padStart(10)}  ${String(spm).padStart(4)}  ${hr.padStart(7)}`,
+          );
+        }
+      }
+
+      if (strokesSummary != null) {
+        console.log();
+        console.log(
+          `Stroke data: ${strokesSummary.samples} samples, avg ${strokesSummary.avg_pace_500m ?? "-"}/500m, ${strokesSummary.avg_spm ?? "-"}spm, HR avg ${strokesSummary.avg_hr ?? "-"} max ${strokesSummary.max_hr ?? "-"}`,
+        );
+      }
+
+      if (linkedNotes.length > 0) {
+        console.log();
+        console.log("Notes:");
+        for (const n of linkedNotes) {
+          console.log(`  ${n.date.slice(0, 10)} [${n.type}/${n.author}] ${n.body}`);
+        }
+      }
+    });
+}

package/src/commands/stats.ts

@@ -0,0 +1,196 @@
+import type { Command } from "commander";
+import { hrAtPace, splitShape, splitTable } from "../analysis.ts";
+import { loadConfig, parseGoalDate } from "../config.ts";
+import { formatMeters } from "../display.ts";
+import { printJSON } from "../envelope.ts";
+import { formatSeconds } from "../models.ts";
+import { dataPaths } from "../paths.ts";
+import type { GoalProgress } from "../stats.ts";
+import {
+  buildWeekSummaries,
+  computeGoalProgress,
+  localYMD,
+  recentWeeks,
+  weekSummaryData,
+} from "../stats.ts";
+import { readWorkouts } from "../storage.ts";
+import { resolveWorkout } from "./show.ts";
+
+export interface GoalProjection {
+  projected_total_meters: number;
+  projected_pct: number;
+  shortfall_meters: number;
+}
+
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+
+export function projectGoal(goal: GoalProgress, end: Date, now: Date): GoalProjection {
+  const weeksLeft = Math.max(0, (end.getTime() - now.getTime()) / WEEK_MS);
+  const projected = Math.round(goal.totalMeters + goal.currentAvgPace * weeksLeft);
+  return {
+    projected_total_meters: projected,
+    projected_pct: Math.round((projected / goal.target) * 1000) / 10,
+    shortfall_meters: Math.max(0, goal.target - projected),
+  };
+}
+
+function parseWeeks(raw: string): number {
+  const weeks = parseInt(raw, 10);
+  if (Number.isNaN(weeks) || weeks < 1) {
+    console.error("Error: --weeks must be a positive integer.");
+    process.exit(1);
+  }
+  return weeks;
+}
+
+export function registerStats(program: Command): void {
+  const stats = program.command("stats").description("Derived training statistics");
+
+  stats
+    .command("weekly")
+    .description("Weekly volume, sessions, pace, SPM, and HR")
+    .option("-w, --weeks <n>", "number of weeks", "12")
+    .option("--json", "output as JSON")
+    .action(async (opts: { weeks: string; json?: boolean }) => {
+      const weeks = parseWeeks(opts.weeks);
+      const cfg = await loadConfig();
+      const workouts = await readWorkouts(dataPaths(cfg));
+      const summaries = buildWeekSummaries(workouts, new Date(), weeks).map(weekSummaryData);
+
+      if (opts.json) {
+        printJSON("c2.stats.weekly.v1", { weeks: summaries });
+        return;
+      }
+      console.log("week        meters  sess  pace/500m   spm    hr");
+      for (const s of summaries) {
+        console.log(
+          `${s.week_start}  ${formatMeters(s.meters).padStart(8)}  ${String(s.sessions).padStart(4)}  ${(s.avg_pace_500m ?? "-").padStart(9)}  ${String(s.avg_spm ?? "-").padStart(4)}  ${String(s.avg_hr ?? "-").padStart(4)}`,
+        );
+      }
+    });
+
+  stats
+    .command("goal")
+    .description("Goal trajectory and projection")
+    .option("--json", "output as JSON")
+    .action(async (opts: { json?: boolean }) => {
+      const cfg = await loadConfig();
+      if (!cfg.goal.start_date || !cfg.goal.end_date) {
+        console.error("Goal dates not configured. Run `c2 setup` to set start and end dates.");
+        process.exit(1);
+      }
+      const workouts = await readWorkouts(dataPaths(cfg));
+      const now = new Date();
+      const goal = computeGoalProgress(workouts, cfg, now);
+      const projection = projectGoal(goal, parseGoalDate(cfg.goal.end_date), now);
+      const weeks = recentWeeks(workouts, now, 4);
+      const thisWeek = weeks[0]!;
+
+      if (opts.json) {
+        printJSON("c2.stats.goal.v1", {
+          goal,
+          projection,
+          this_week: {
+            week_start: localYMD(thisWeek.weekStart),
+            meters: thisWeek.meters,
+            sessions: thisWeek.sessions,
+          },
+        });
+        return;
+      }
+      console.log(
+        `Progress: ${formatMeters(goal.totalMeters)} / ${formatMeters(goal.target)} (${((goal.progress ?? 0) * 100).toFixed(1)}%)`,
+      );
+      console.log(`Required pace: ${formatMeters(goal.requiredPace)} m/wk`);
+      console.log(`Recent average: ${formatMeters(goal.currentAvgPace)} m/wk`);
+      console.log(
+        `Projection at current pace: ${formatMeters(projection.projected_total_meters)} m (${projection.projected_pct}%)`,
+      );
+      if (projection.shortfall_meters > 0) {
+        console.log(`Projected shortfall: ${formatMeters(projection.shortfall_meters)} m`);
+      } else {
+        console.log("On track to exceed goal.");
+      }
+      console.log(
+        `This week so far: ${formatMeters(thisWeek.meters)} m (${thisWeek.sessions} sessions)`,
+      );
+    });
+
+  stats
+    .command("splits <id>")
+    .description("Split analysis for one workout (id or 'last')")
+    .option("--json", "output as JSON")
+    .action(async (ref: string, opts: { json?: boolean }) => {
+      const cfg = await loadConfig();
+      const workouts = await readWorkouts(dataPaths(cfg));
+      const w = resolveWorkout(workouts, ref);
+      if (w == null) {
+        console.error(
+          ref === "last" ? "No workouts found. Run `c2 sync` first." : `No workout with id ${ref}.`,
+        );
+        process.exit(1);
+      }
+      const rows = splitTable(w);
+      const shape = splitShape(rows);
+
+      if (opts.json) {
+        printJSON("c2.stats.splits.v1", {
+          workout_id: w.id,
+          date: w.date,
+          distance: w.distance,
+          split_shape: shape,
+          splits: rows,
+        });
+        return;
+      }
+      if (rows.length === 0) {
+        console.log(`Workout ${w.id} has no split data.`);
+        return;
+      }
+      console.log(`Workout ${w.id} — ${w.date} — ${formatMeters(w.distance)}m — ${shape} splits`);
+      for (const s of rows) {
+        console.log(
+          `  ${s.index}: ${s.distance != null ? `${formatMeters(s.distance)}m` : "-"}  ${s.pace_500m ?? "-"}/500m  ${s.stroke_rate ?? "-"}spm  HR ${s.hr_avg ?? "-"}`,
+        );
+      }
+    });
+
+  stats
+    .command("hr-pace")
+    .description("Average heart rate by steady pace band (fitness proxy)")
+    .option("-w, --weeks <n>", "window in weeks", "8")
+    .option("--json", "output as JSON")
+    .action(async (opts: { weeks: string; json?: boolean }) => {
+      const weeks = parseWeeks(opts.weeks);
+      const cfg = await loadConfig();
+      const workouts = await readWorkouts(dataPaths(cfg));
+      const bands = hrAtPace(workouts, new Date(), weeks);
+
+      if (opts.json) {
+        printJSON("c2.stats.hr-pace.v1", { weeks, bands });
+        return;
+      }
+      if (bands.length === 0) {
+        console.log("No steady workouts with heart rate data in the window.");
+        return;
+      }
+      console.log(`Steady pace bands over the last ${weeks} weeks (HR avg, early→late half):`);
+      for (const b of bands) {
+        const trend =
+          b.hr_delta == null
+            ? ""
+            : b.hr_delta < 0
+              ? `  ↓${Math.abs(b.hr_delta)} (improving)`
+              : b.hr_delta > 0
+                ? `  ↑${b.hr_delta} (watch)`
+                : "  → flat";
+        const halves =
+          b.early_avg_hr != null && b.late_avg_hr != null
+            ? ` (${b.early_avg_hr}→${b.late_avg_hr})`
+            : "";
+        console.log(
+          `  ${b.band}/500m: HR ${b.avg_hr}${halves} across ${b.workouts} workout${b.workouts === 1 ? "" : "s"}${trend}`,
+        );
+      }
+    });
+}

package/src/commands/status.ts

@@ -1,26 +1,50 @@
 import type { Command } from "commander";
 import { loadConfig } from "../config.ts";
 import { formatMeters, formatMetersPerWeek, formatPercent } from "../display.ts";
-import { calendarDay } from "../models.ts";
-import { computeGoalProgress, mondayOf, workoutsInRange } from "../stats.ts";
+import { printJSON } from "../envelope.ts";
+import { dataPaths } from "../paths.ts";
+import { computeGoalProgress, localYMD, recentWeeks } from "../stats.ts";
 import { readWorkouts } from "../storage.ts";
 
 export function registerStatus(program: Command): void {
   program
     .command("status")
     .description("Show progress toward your distance goal")
-    .action(async () => {
+    .option("--json", "output as JSON")
+    .action(async (opts: { json?: boolean }) => {
       const cfg = await loadConfig();
       if (!cfg.goal.start_date || !cfg.goal.end_date) {
         console.error("Goal dates not configured. Run `c2 setup` to set start and end dates.");
         process.exit(1);
       }
-      const workouts = await readWorkouts();
-      if (workouts.length === 0) {
+      const paths = dataPaths(cfg);
+      const workouts = await readWorkouts(paths);
+      const now = new Date();
+      const goal = computeGoalProgress(workouts, cfg, now);
+      const weeks = recentWeeks(workouts, now, 4);
+      const thisWeek = weeks[0]!;
+
+      if (!opts.json && workouts.length === 0) {
         console.log("No workouts found. Run `c2 sync` first.");
         return;
       }
-      const goal = computeGoalProgress(workouts, cfg);
+
+      if (opts.json) {
+        printJSON("c2.status.v1", {
+          goal,
+          this_week: {
+            week_start: localYMD(thisWeek.weekStart),
+            meters: thisWeek.meters,
+            sessions: thisWeek.sessions,
+          },
+          recent_weeks: weeks.map((w) => ({
+            week_start: localYMD(w.weekStart),
+            meters: w.meters,
+            sessions: w.sessions,
+          })),
+        });
+        return;
+      }
 
       console.log(`Goal: ${formatMeters(goal.target)}m`);
       console.log(`Season start: ${cfg.goal.start_date}`);
@@ -29,29 +53,22 @@ export function registerStatus(program: Command): void {
       );
       console.log(`Weeks elapsed: ${goal.weeksElapsed} / ${goal.totalWeeks}`);
       console.log(`Required pace: ${formatMetersPerWeek(goal.requiredPace)}`);
+      console.log(
+        `This week so far: ${formatMeters(thisWeek.meters)} (${thisWeek.sessions} sessions)`,
+      );
       console.log();
 
-      const today = new Date();
       console.log("Last 4 weeks:");
-      for (let i = 0; i < 4; i++) {
-        const weekStart = mondayOf(today);
-        weekStart.setDate(weekStart.getDate() - i * 7);
-        const weekEnd = new Date(weekStart);
-        weekEnd.setDate(weekEnd.getDate() + 7);
-
-        const weekWorkouts = workoutsInRange(workouts, weekStart, weekEnd);
-        const meters = weekWorkouts.reduce((sum, w) => sum + w.distance, 0);
-        const sessions = new Set(weekWorkouts.map(calendarDay)).size;
-
-        const mm = String(weekStart.getMonth() + 1).padStart(2, "0");
-        const dd = String(weekStart.getDate()).padStart(2, "0");
-        console.log(`  Week of ${mm}/${dd}: ${formatMeters(meters)} (${sessions} sessions)`);
+      for (const w of weeks) {
+        const mm = String(w.weekStart.getMonth() + 1).padStart(2, "0");
+        const dd = String(w.weekStart.getDate()).padStart(2, "0");
+        console.log(`  Week of ${mm}/${dd}: ${formatMeters(w.meters)} (${w.sessions} sessions)`);
       }
       console.log();
 
       if (goal.weeksElapsed > 0) {
-        const indicator = goal.onPace ? "on pace \u2713" : "behind pace \u2717";
-        console.log(`Current avg: ${formatMetersPerWeek(goal.currentAvgPace)} \u2014 ${indicator}`);
+        const indicator = goal.onPace ? "on pace ✓" : "behind pace ✗";
+        console.log(`Current avg: ${formatMetersPerWeek(goal.currentAvgPace)} — ${indicator}`);
       }
     });
 }

package/src/commands/sync.ts

@@ -1,18 +1,34 @@
 import type { Command } from "commander";
 import { C2Client } from "../api/client.ts";
-import { ensureDirs, loadConfig, saveConfig } from "../config.ts";
+import { loadConfig } from "../config.ts";
+import { initStore, inspectDataDir } from "../data.ts";
 import type { Workout } from "../models.ts";
-import { appendWorkouts, hasStrokeData, workoutCount, writeStrokeData } from "../storage.ts";
+import { compactNotes } from "../notes.ts";
+import type { DataPaths } from "../paths.ts";
+import { dataPaths } from "../paths.ts";
+import {
+  appendWorkouts,
+  hasStrokeData,
+  readMeta,
+  SCHEMA_VERSION,
+  workoutCount,
+  writeMeta,
+  writeStrokeData,
+} from "../storage.ts";
 
-async function syncStrokes(client: C2Client, workouts: Workout[]): Promise<number> {
+async function syncStrokes(
+  client: C2Client,
+  paths: DataPaths,
+  workouts: Workout[],
+): Promise<number> {
   let count = 0;
   let failures = 0;
   for (const w of workouts) {
-    if (!w.stroke_data || (await hasStrokeData(w.id))) continue;
+    if (!w.stroke_data || (await hasStrokeData(paths, w.id))) continue;
     try {
       const strokes = await client.getStrokes(w.id);
       if (strokes.length > 0) {
-        await writeStrokeData(w.id, strokes);
+        await writeStrokeData(paths, w.id, strokes);
         count++;
       }
     } catch (err) {
@@ -39,30 +55,62 @@ export function registerSync(program: Command): void {
         console.error("No API token configured. Run `c2 setup` first.");
         process.exit(1);
       }
-      await ensureDirs();
+      const paths = dataPaths(cfg);
+      const inspection = await inspectDataDir(paths);
+      if (inspection.state === "foreign") {
+        console.error(
+          `${paths.root} exists but is not a c2 data store. Fix data_dir via \`c2 setup\`.`,
+        );
+        process.exit(1);
+      }
+      if (!inspection.writable) {
+        console.error(`Cannot write to ${paths.root}.`);
+        process.exit(1);
+      }
+      const now = new Date();
+      await initStore(paths, now);
 
       const client = C2Client.fromConfig(cfg);
-      const from = cfg.sync.last_sync ?? "";
+      const meta = await readMeta(paths);
+      let from = meta?.last_sync ?? "";
+      if (!from && cfg.sync.last_sync && (await workoutCount(paths)) > 0) {
+        from = cfg.sync.last_sync;
+      }
 
       if (from) {
         console.log(`Syncing workouts since ${from}...`);
       } else {
-        console.log("First sync \u2014 pulling all workouts...");
+        console.log("First sync — pulling all workouts...");
       }
 
       const workouts = await client.getAllResults(from, "");
-      const written = await appendWorkouts(workouts);
+      const written = await appendWorkouts(paths, workouts);
       console.log(`Fetched ${workouts.length} workouts, ${written} new.`);
 
-      const strokeCount = await syncStrokes(client, workouts);
+      const strokeCount = await syncStrokes(client, paths, workouts);
       if (strokeCount > 0) {
         console.log(`Fetched stroke data for ${strokeCount} workouts.`);
       }
 
-      cfg.sync.last_sync = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
-      await saveConfig(cfg);
+      await writeMeta(paths, {
+        schema_version: meta?.schema_version ?? SCHEMA_VERSION,
+        created: meta?.created ?? now.toISOString(),
+        last_sync: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+      });
+
+      const compacted = await compactNotes(paths, now);
+      for (const year of compacted.skippedYears) {
+        console.error(
+          `Warning: notes/archive/${year}.jsonl has corrupt lines; left untouched (run \`c2 data doctor\`).`,
+        );
+      }
+      if (compacted.archived > 0) {
+        console.log(
+          `Compacted ${compacted.archived} note${compacted.archived === 1 ? "" : "s"} into ${compacted.years.map((y) => `${y}.jsonl`).join(", ")}.`,
+        );
+      }
 
-      const total = await workoutCount();
+      const total = await workoutCount(paths);
       console.log(`Total workouts: ${total}`);
     });
 }

package/src/commands/trend.ts

@@ -1,6 +1,9 @@
 import type { Command } from "commander";
+import { loadConfig } from "../config.ts";
 import { formatMeters, paceArrow, sparkBar, trendArrow } from "../display.ts";
-import { buildWeekSummaries, type WeekSummary } from "../stats.ts";
+import { printJSON } from "../envelope.ts";
+import { dataPaths } from "../paths.ts";
+import { buildWeekSummaries, type WeekSummary, weekSummaryData } from "../stats.ts";
 import { readWorkouts } from "../storage.ts";
 
 function fmtDate(d: Date): string {
@@ -87,12 +90,10 @@ export function registerTrend(program: Command): void {
     .command("trend")
     .description("Show training trends over time")
     .option("-w, --weeks <n>", "number of weeks to display", "8")
-    .action(async (opts: { weeks: string }) => {
-      const workouts = await readWorkouts();
-      if (workouts.length === 0) {
-        console.log("No workouts found. Run `c2 sync` first.");
-        return;
-      }
+    .option("--json", "output as JSON")
+    .action(async (opts: { weeks: string; json?: boolean }) => {
+      const cfg = await loadConfig();
+      const workouts = await readWorkouts(dataPaths(cfg));
 
       const weeks = parseInt(opts.weeks, 10);
       if (Number.isNaN(weeks) || weeks < 1) {
@@ -101,6 +102,16 @@ export function registerTrend(program: Command): void {
       }
       const summaries = buildWeekSummaries(workouts, new Date(), weeks);
 
+      if (opts.json) {
+        printJSON("c2.trend.v1", { weeks: summaries.map(weekSummaryData) });
+        return;
+      }
+
+      if (workouts.length === 0) {
+        console.log("No workouts found. Run `c2 sync` first.");
+        return;
+      }
+
       printVolumeTrend(summaries);
       console.log();
       printPaceTrend(summaries);

package/src/config.ts

@@ -1,33 +1,31 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
 export interface Config {
+  data_dir: string;
   api: { base_url: string; token: string };
   sync: { last_sync?: string; machine_type: string };
   goal: { target_meters: number; start_date: string; end_date: string };
   display: { date_format: string };
 }
 
-export function defaultConfig(): Config {
-  return {
-    api: { base_url: "https://log.concept2.com", token: "" },
-    sync: { machine_type: "rower" },
-    goal: { target_meters: 1_000_000, start_date: "", end_date: "" },
-    display: { date_format: "%m/%d" },
-  };
-}
-
 export function configDir(): string {
   return join(homedir(), ".config", "c2");
 }
 
-export function dataDir(): string {
+export function defaultDataDir(): string {
   return join(configDir(), "data");
 }
 
-export async function ensureDirs(): Promise<void> {
-  await mkdir(join(dataDir(), "strokes"), { recursive: true });
+export function defaultConfig(): Config {
+  return {
+    data_dir: defaultDataDir(),
+    api: { base_url: "https://log.concept2.com", token: "" },
+    sync: { machine_type: "rower" },
+    goal: { target_meters: 1_000_000, start_date: "", end_date: "" },
+    display: { date_format: "%m/%d" },
+  };
 }
 
 export async function loadConfig(): Promise<Config> {
@@ -36,7 +34,12 @@ export async function loadConfig(): Promise<Config> {
   try {
     const text = await readFile(path, "utf-8");
     const parsed = JSON.parse(text) as Partial<Config>;
+    const dataDir =
+      typeof parsed.data_dir === "string" && parsed.data_dir.trim() !== ""
+        ? parsed.data_dir
+        : defaults.data_dir;
     return {
+      data_dir: dataDir,
       api: { ...defaults.api, ...parsed.api },
       sync: { ...defaults.sync, ...parsed.sync },
       goal: { ...defaults.goal, ...parsed.goal },
@@ -54,7 +57,8 @@ export async function saveConfig(cfg: Config): Promise<void> {
   const path = join(configDir(), "config.json");
   await mkdir(configDir(), { recursive: true });
   const text = JSON.stringify(cfg, null, 2);
-  await writeFile(path, `${text}\n`, "utf-8");
+  await writeFile(path, `${text}\n`, { encoding: "utf-8", mode: 0o600 });
+  await chmod(path, 0o600);
 }
 
 export function parseGoalDate(s: string): Date {