@richhaase/c2 0.3.3 → 0.4.0

package/src/commands/note.ts

@@ -0,0 +1,237 @@
+import type { Command } from "commander";
+import { loadConfig } from "../config.ts";
+import { ensureStoreForWrite, rejectForeignStore } from "../data.ts";
+import { printJSON } from "../envelope.ts";
+import { isValidYMD } from "../models.ts";
+import {
+  filterNotes,
+  isNoteShaped,
+  localISO,
+  NOTE_AUTHORS,
+  NOTE_TYPES,
+  type NoteAuthor,
+  type NoteRecord,
+  type NoteType,
+  readAllNotes,
+  ulid,
+  writeNote,
+} from "../notes.ts";
+import { dataPaths } from "../paths.ts";
+import { readWorkouts } from "../storage.ts";
+import { resolveWorkout } from "./show.ts";
+
+async function readBody(bodyArg: string | undefined): Promise<string> {
+  if (bodyArg != null && bodyArg !== "-") return bodyArg.trim();
+  const text = await new Response(Bun.stdin.stream()).text();
+  return text.trim();
+}
+
+export function parseNoteDate(raw: string): string | null {
+  const prefix = /^(\d{4}-\d{2}-\d{2})([T ].+)?$/.exec(raw);
+  if (prefix == null || !isValidYMD(prefix[1]!)) return null;
+  if (/(?:[+-]\d{2}:\d{2}|Z)$/.test(raw)) {
+    let normalized = raw.replace(" ", "T");
+    if (normalized.endsWith("Z")) normalized = `${normalized.slice(0, -1)}+00:00`;
+    if (!/^\d{4}-\d{2}-\d{2}T\S+$/.test(normalized)) return null;
+    if (Number.isNaN(new Date(normalized).getTime())) return null;
+    return normalized;
+  }
+  const d = prefix[2] == null ? new Date(`${raw}T12:00:00`) : new Date(raw);
+  if (Number.isNaN(d.getTime())) return null;
+  return localISO(d);
+}
+
+function noteLine(n: NoteRecord): string {
+  const workout = n.workout_id != null ? ` w:${n.workout_id}` : "";
+  const tags = n.tags && n.tags.length > 0 ? ` #${n.tags.join(" #")}` : "";
+  return `${n.date.slice(0, 10)}  [${n.type}/${n.author}]${workout}${tags}  ${n.body}`;
+}
+
+export function registerNote(program: Command): void {
+  const note = program.command("note").description("Coaching notes and subjective reports");
+
+  note
+    .command("add [body]")
+    .description("Record a note (body as argument, or '-' / omitted to read stdin)")
+    .option("--type <type>", "subjective, observation, or lesson", "observation")
+    .option("--workout <id>", "link to a workout id or 'last'")
+    .option("--tags <tags>", "comma-separated tags")
+    .option("--author <author>", "athlete or coach", "athlete")
+    .option("--date <date>", "backdate the note (YYYY-MM-DD or ISO timestamp)")
+    .action(
+      async (
+        bodyArg: string | undefined,
+        opts: { type: string; workout?: string; tags?: string; author: string; date?: string },
+      ) => {
+        if (!(NOTE_TYPES as readonly string[]).includes(opts.type)) {
+          console.error(`Error: --type must be one of ${NOTE_TYPES.join(", ")}.`);
+          process.exit(1);
+        }
+        if (!(NOTE_AUTHORS as readonly string[]).includes(opts.author)) {
+          console.error(`Error: --author must be one of ${NOTE_AUTHORS.join(", ")}.`);
+          process.exit(1);
+        }
+
+        let backdate: string | null = null;
+        if (opts.date) {
+          backdate = parseNoteDate(opts.date);
+          if (backdate == null) {
+            console.error(`Error: invalid --date "${opts.date}".`);
+            process.exit(1);
+          }
+        }
+
+        const body = await readBody(bodyArg);
+        if (body === "") {
+          console.error("Error: note body is empty.");
+          process.exit(1);
+        }
+
+        const cfg = await loadConfig();
+        const paths = dataPaths(cfg);
+        const now = new Date();
+        const foreign = await rejectForeignStore(paths);
+        if (foreign != null) {
+          console.error(foreign);
+          process.exit(1);
+        }
+
+        let workoutId: number | undefined;
+        if (opts.workout) {
+          const workouts = await readWorkouts(paths);
+          const w = resolveWorkout(workouts, opts.workout);
+          if (w == null) {
+            console.error(`Error: no workout matching "${opts.workout}".`);
+            process.exit(1);
+          }
+          workoutId = w.id;
+        }
+
+        const storeError = await ensureStoreForWrite(paths, now);
+        if (storeError != null) {
+          console.error(storeError);
+          process.exit(1);
+        }
+
+        const date = backdate ?? localISO(now);
+
+        const record: NoteRecord = {
+          id: ulid(now),
+          date,
+          type: opts.type as NoteType,
+          workout_id: workoutId,
+          tags: opts.tags
+            ? opts.tags
+                .split(",")
+                .map((t) => t.trim())
+                .filter((t) => t !== "")
+            : undefined,
+          body,
+          author: opts.author as NoteAuthor,
+        };
+        if (!isNoteShaped(record)) {
+          console.error("Error: note would not round-trip; check --date and field values.");
+          process.exit(1);
+        }
+        await writeNote(paths, record);
+        console.log(record.id);
+      },
+    );
+
+  note
+    .command("list")
+    .description("List notes, newest last")
+    .option("--type <type>", "filter by type")
+    .option("--since <date>", "only notes on or after date (YYYY-MM-DD)")
+    .option("--workout <id>", "only notes linked to a workout id")
+    .option("-n, --count <n>", "show only the most recent n notes")
+    .option("--json", "output as JSON")
+    .action(
+      async (opts: {
+        type?: string;
+        since?: string;
+        workout?: string;
+        count?: string;
+        json?: boolean;
+      }) => {
+        if (opts.since && !isValidYMD(opts.since)) {
+          console.error(`Error: invalid --since date "${opts.since}" (expected YYYY-MM-DD).`);
+          process.exit(1);
+        }
+        if (opts.type && !(NOTE_TYPES as readonly string[]).includes(opts.type)) {
+          console.error(`Error: --type must be one of ${NOTE_TYPES.join(", ")}.`);
+          process.exit(1);
+        }
+        let workoutId: number | undefined;
+        if (opts.workout != null) {
+          workoutId = Number(opts.workout);
+          if (!Number.isInteger(workoutId)) {
+            console.error(`Error: invalid --workout id "${opts.workout}".`);
+            process.exit(1);
+          }
+        }
+        const cfg = await loadConfig();
+        const paths = dataPaths(cfg);
+        const foreign = await rejectForeignStore(paths);
+        if (foreign != null) {
+          console.error(foreign);
+          process.exit(1);
+        }
+        let notes = filterNotes(await readAllNotes(paths), {
+          type: opts.type,
+          since: opts.since,
+          workoutId,
+        });
+        if (opts.count != null) {
+          const n = parseInt(opts.count, 10);
+          if (Number.isNaN(n) || n < 1) {
+            console.error("Error: --count must be a positive integer.");
+            process.exit(1);
+          }
+          notes = notes.slice(-n);
+        }
+
+        if (opts.json) {
+          printJSON("c2.notes.v1", { count: notes.length, notes });
+          return;
+        }
+        if (notes.length === 0) {
+          console.log("No notes found.");
+          return;
+        }
+        for (const n of notes) {
+          console.log(noteLine(n));
+        }
+      },
+    );
+
+  note
+    .command("show <id>")
+    .description("Show one note in full")
+    .option("--json", "output as JSON")
+    .action(async (id: string, opts: { json?: boolean }) => {
+      const cfg = await loadConfig();
+      const paths = dataPaths(cfg);
+      const foreign = await rejectForeignStore(paths);
+      if (foreign != null) {
+        console.error(foreign);
+        process.exit(1);
+      }
+      const match = (await readAllNotes(paths)).find((n) => n.id === id);
+      if (match == null) {
+        console.error(`No note with id ${id}.`);
+        process.exit(1);
+      }
+      if (opts.json) {
+        printJSON("c2.note.v1", match);
+        return;
+      }
+      console.log(`Id: ${match.id}`);
+      console.log(`Date: ${match.date}`);
+      console.log(`Type: ${match.type} (${match.author})`);
+      if (match.workout_id != null) console.log(`Workout: ${match.workout_id}`);
+      if (match.tags && match.tags.length > 0) console.log(`Tags: ${match.tags.join(", ")}`);
+      console.log();
+      console.log(match.body);
+    });
+}

package/src/commands/report.ts

@@ -1,11 +1,17 @@
-import { mkdtemp, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import type { Command } from "commander";
-import { loadConfig } from "../config.ts";
-import { formatMeters } from "../display.ts";
+import { splitShape, splitTable } from "../analysis.ts";
+import { loadConfig, parseGoalDate } from "../config.ts";
+import { rejectForeignStore } from "../data.ts";
+import { formatMeters, workoutJSON } from "../display.ts";
+import { printJSON } from "../envelope.ts";
 import type { Workout } from "../models.ts";
 import { calendarDay, pace500m, pace500mSeconds } from "../models.ts";
+import { filterNotes, type NoteRecord, readAllNotes } from "../notes.ts";
+import type { DataPaths } from "../paths.ts";
+import { dataPaths } from "../paths.ts";
 import { sessionCount } from "../sessions.ts";
 import {
   buildWeekSummaries,
@@ -13,9 +19,12 @@ import {
   type GoalProgress,
   mondayOf,
   type WeekSummary,
+  weekSummaryData,
   workoutsInRange,
 } from "../stats.ts";
 import { readWorkouts } from "../storage.ts";
+import { listNarratives } from "./docs.ts";
+import { projectGoal } from "./stats.ts";
 
 const MONTH_NAMES = [
   "Jan",
@@ -385,12 +394,158 @@ function buildProjection(goal: GoalProgress, workouts: Workout[]): string {
 </div>`;
 }
 
+export interface CoachingContent {
+  narrative: { date: string; text: string } | null;
+  notes: NoteRecord[];
+  planExcerpt: string | null;
+}
+
+const EMPTY_COACHING: CoachingContent = { narrative: null, notes: [], planExcerpt: null };
+
+const RECENT_NOTE_DAYS = 14;
+const MAX_RECENT_NOTES = 20;
+const PLAN_EXCERPT_MAX_CHARS = 1500;
+
+async function readIfExists(path: string): Promise<string | null> {
+  try {
+    return await readFile(path, "utf-8");
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR") return null;
+    throw err;
+  }
+}
+
+export async function gatherCoaching(paths: DataPaths, now: Date): Promise<CoachingContent> {
+  const since = new Date(now);
+  since.setDate(since.getDate() - RECENT_NOTE_DAYS);
+  const sinceKey = `${since.getFullYear()}-${String(since.getMonth() + 1).padStart(2, "0")}-${String(since.getDate()).padStart(2, "0")}`;
+  const notes = filterNotes(await readAllNotes(paths), { since: sinceKey }).slice(
+    -MAX_RECENT_NOTES,
+  );
+
+  let narrative: CoachingContent["narrative"] = null;
+  const dates = await listNarratives(paths);
+  const latest = dates[dates.length - 1];
+  if (latest != null) {
+    const text = await readIfExists(paths.narrativeFile(latest));
+    if (text != null && text.trim() !== "") narrative = { date: latest, text };
+  }
+
+  let planExcerpt: string | null = null;
+  const plan = await readIfExists(paths.plan);
+  if (plan != null && plan.trim() !== "") {
+    const sections = plan.split(/\n(?=## )/);
+    const substantive = (s: string) =>
+      s.split("\n").some((l) => {
+        const t = l.trim();
+        return t !== "" && !/^#{1,4}\s/.test(t) && t !== "---";
+      });
+    let end = 1;
+    let excerpt = sections[0]!.trim();
+    while (!substantive(excerpt) && end < sections.length) {
+      excerpt = `${excerpt}\n\n${sections[end]!.trim()}`;
+      end++;
+    }
+    if (excerpt.length > PLAN_EXCERPT_MAX_CHARS) {
+      excerpt = `${excerpt.slice(0, PLAN_EXCERPT_MAX_CHARS)}…`;
+    } else if (sections.length > end) {
+      excerpt = `${excerpt}\n\n_(full plan: \`c2 plan show\`)_`;
+    }
+    planExcerpt = excerpt;
+  }
+
+  return { narrative, notes, planExcerpt };
+}
+
+function mdLite(text: string): string {
+  const blocks: string[] = [];
+  let paragraph: string[] = [];
+  let list: string[] = [];
+
+  const flushParagraph = () => {
+    if (paragraph.length > 0) {
+      blocks.push(`<p>${paragraph.join(" ")}</p>`);
+      paragraph = [];
+    }
+  };
+  const flushList = () => {
+    if (list.length > 0) {
+      blocks.push(`<ul>${list.map((i) => `<li>${i}</li>`).join("")}</ul>`);
+      list = [];
+    }
+  };
+
+  for (const rawLine of text.split("\n")) {
+    const line = esc(rawLine.trim());
+    if (line === "") {
+      flushParagraph();
+      flushList();
+      continue;
+    }
+    const heading = /^(#{1,4})\s+(.*)$/.exec(line);
+    if (heading != null) {
+      flushParagraph();
+      flushList();
+      const level = heading[1]!.length <= 2 ? "h3" : "h4";
+      blocks.push(`<${level}>${heading[2]}</${level}>`);
+      continue;
+    }
+    const item = /^[-*]\s+(.*)$/.exec(line);
+    if (item != null) {
+      flushParagraph();
+      list.push(item[1]!);
+      continue;
+    }
+    flushList();
+    paragraph.push(line);
+  }
+  flushParagraph();
+  flushList();
+  return blocks.join("\n");
+}
+
+function buildNarrativeSection(narrative: { date: string; text: string }): string {
+  return `<div class="section">
+  <h2>Coach's Report &mdash; ${esc(narrative.date)}</h2>
+  <div class="prose">
+${mdLite(narrative.text)}
+  </div>
+</div>`;
+}
+
+function buildNotesSection(notes: NoteRecord[]): string {
+  const rows = notes
+    .map((n) => {
+      const workout = n.workout_id != null ? ` &middot; workout ${n.workout_id}` : "";
+      return `  <div class="note-row">
+    <div class="note-meta">${esc(n.date.slice(0, 10))} &middot; ${esc(n.type)} (${esc(n.author)})${workout}</div>
+    <div class="note-body">${esc(n.body)}</div>
+  </div>`;
+    })
+    .join("\n");
+  return `<div class="section">
+  <h2>Recent Notes</h2>
+${rows}
+</div>`;
+}
+
+function buildPlanSection(excerpt: string): string {
+  return `<div class="section">
+  <h2>Training Plan</h2>
+  <div class="prose">
+${mdLite(excerpt)}
+  </div>
+</div>`;
+}
+
 function buildHTML(
   goal: GoalProgress,
   summaries: WeekSummary[],
   allWorkouts: Workout[],
   windowedWorkouts: Workout[],
   recentCount: number,
+  coaching: CoachingContent,
 ): string {
   const sessions = sessionCount(windowedWorkouts);
   const avgPace = avgPaceForWorkouts(windowedWorkouts);
@@ -463,6 +618,18 @@ function buildHTML(
     margin-bottom: 24px;
   }
 
+  .prose { font-size: 14px; }
+  .prose p { margin-bottom: 10px; }
+  .prose h3 { color: #f0f6fc; font-size: 15px; font-weight: 600; margin: 14px 0 6px; }
+  .prose h4 { color: #c9d1d9; font-size: 13px; font-weight: 600; margin: 12px 0 4px; }
+  .prose ul { margin: 0 0 10px 20px; }
+  .prose li { margin-bottom: 4px; }
+
+  .note-row { padding: 10px 0; border-bottom: 1px solid #21262d; }
+  .note-row:last-child { border-bottom: none; }
+  .note-meta { color: #8b949e; font-size: 11px; text-transform: uppercase; letter-spacing: 0.3px; margin-bottom: 3px; }
+  .note-body { font-size: 13px; }
+
   .progress-container {
     position: relative;
     background: #21262d;
@@ -636,14 +803,20 @@ ${buildStatsCards(goal, sessions, avgPace, avgHR)}
 
 ${buildGoalProgress(goal)}
 
+${coaching.narrative != null ? buildNarrativeSection(coaching.narrative) : ""}
+
 ${buildWeeklyVolume(summaries, goal.requiredPace)}
 
 ${buildWeeklyTrends(summaries)}
 
 ${buildRecentWorkouts(allWorkouts, recentCount)}
 
+${coaching.notes.length > 0 ? buildNotesSection(coaching.notes) : ""}
+
 ${buildProjection(goal, allWorkouts)}
 
+${coaching.planExcerpt != null ? buildPlanSection(coaching.planExcerpt) : ""}
+
 <div style="text-align: center; color: #484f58; font-size: 12px; margin-top: 32px; padding-bottom: 16px;">
   Generated by c2 &middot; Data from Concept2 Logbook &middot; ${fullDate(today)}
 </div>
@@ -658,33 +831,83 @@ export function registerReport(program: Command): void {
     .description("Generate HTML progress report and open in browser")
     .option("-o, --output <file>", "save to a specific file instead of a temp file")
     .option("-w, --weeks <n>", "weeks of history to show", "12")
+    .option("--data", "emit the report content as JSON instead of HTML")
     .option("--no-open", "don't open in browser")
-    .action(async (opts: { output?: string; weeks: string; open: boolean }) => {
+    .action(async (opts: { output?: string; weeks: string; data?: boolean; open: 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();
+      const paths = dataPaths(cfg);
+      const foreign = await rejectForeignStore(paths);
+      if (foreign != null) {
+        console.error(foreign);
+        process.exit(1);
+      }
+      const workouts = await readWorkouts(paths);
 
-      if (workouts.length === 0) {
+      if (workouts.length === 0 && !opts.data) {
         console.log("No workouts found. Run `c2 sync` first.");
         return;
       }
 
-      const goal = computeGoalProgress(workouts, cfg);
       const weeks = parseInt(opts.weeks, 10);
       if (Number.isNaN(weeks) || weeks < 1) {
         console.error("Error: --weeks must be a positive integer.");
         process.exit(1);
       }
       const now = new Date();
+      const goal = computeGoalProgress(workouts, cfg, now);
       const summaries = buildWeekSummaries(workouts, now, weeks);
       const thisMonday = mondayOf(now);
       const cutoff = new Date(thisMonday);
       cutoff.setDate(cutoff.getDate() - (weeks - 1) * 7);
       const windowedWorkouts = workoutsInRange(workouts, cutoff, now);
-      const html = buildHTML(goal, summaries, workouts, windowedWorkouts, 10);
+      const coaching = await gatherCoaching(paths, now);
+
+      if (opts.data) {
+        const sorted = [...workouts].sort((a, b) => b.date.localeCompare(a.date));
+        const latest = sorted[0] ?? null;
+        let splitsSource: Workout | null = null;
+        if (latest != null) {
+          const day = calendarDay(latest);
+          splitsSource =
+            sorted
+              .filter((w) => calendarDay(w) === day && (w.workout?.splits?.length ?? 0) > 0)
+              .sort((a, b) => b.distance - a.distance)[0] ?? null;
+        }
+        const latestSplits = splitsSource != null ? splitTable(splitsSource) : [];
+        printJSON("c2.report.v1", {
+          period: { weeks, to: latest != null ? calendarDay(latest) : null },
+          summary: {
+            total_meters: goal.totalMeters,
+            sessions: sessionCount(windowedWorkouts),
+            avg_pace_500m_seconds:
+              Math.round(avgPaceForWorkouts(windowedWorkouts) * 10) / 10 || null,
+            avg_hr: avgHRForWorkouts(windowedWorkouts) || null,
+          },
+          goal,
+          projection: projectGoal(goal, parseGoalDate(cfg.goal.end_date), now),
+          weekly: summaries.map(weekSummaryData),
+          recent_workouts: sorted.slice(0, 10).map(workoutJSON),
+          latest_splits:
+            splitsSource != null && latestSplits.length > 0
+              ? {
+                  workout_id: splitsSource.id,
+                  date: splitsSource.date,
+                  split_shape: splitShape(latestSplits),
+                  splits: latestSplits,
+                }
+              : null,
+          narrative: coaching.narrative,
+          notes: coaching.notes,
+          plan_excerpt: coaching.planExcerpt,
+        });
+        return;
+      }
+
+      const html = buildHTML(goal, summaries, workouts, windowedWorkouts, 10, coaching);
 
       let outPath: string;
       if (opts.output) {

package/src/commands/setup.ts

@@ -5,12 +5,13 @@ import {
   type Config,
   configDir,
   defaultConfig,
-  ensureDirs,
   loadConfig,
   parseGoalDate,
   saveConfig,
 } from "../config.ts";
+import { initStore, inspectDataDir, storeSummary } from "../data.ts";
 import { formatMeters } from "../display.ts";
+import { canonicalRoot, pathsFor } from "../paths.ts";
 
 function maskToken(token: string): string {
   if (token.length <= 4) return token;
@@ -23,6 +24,60 @@ function promptValue(label: string, current: string, mask = false): string {
   return (input ?? "").trim() || current;
 }
 
+function confirm(question: string, defaultYes: boolean): boolean {
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  const input = (prompt(`${question} ${suffix}`) ?? "").trim().toLowerCase();
+  if (input === "") return defaultYes;
+  return input === "y" || input === "yes";
+}
+
+async function chooseDataDir(current: string): Promise<string> {
+  const input = promptValue("Data directory", current);
+  const paths = pathsFor(input);
+  const inspection = await inspectDataDir(paths);
+
+  if (!inspection.writable) {
+    console.error(`Cannot write to ${paths.root}; keeping ${current}.`);
+    return current;
+  }
+
+  switch (inspection.state) {
+    case "missing":
+      if (!confirm(`${paths.root} does not exist. Create it?`, true)) {
+        console.log(`Keeping ${current}.`);
+        return current;
+      }
+      break;
+    case "store": {
+      const summary = await storeSummary(paths);
+      if (summary.workouts > 0) {
+        console.log(
+          `Found existing c2 store: ${summary.workouts} workouts (${summary.firstDate} → ${summary.lastDate}), ${summary.strokeFiles} stroke files, ${summary.notes} notes.`,
+        );
+      } else {
+        console.log("Found existing empty c2 store.");
+      }
+      break;
+    }
+    case "empty":
+      break;
+    case "foreign":
+      if (
+        !confirm(
+          `${paths.root} is not empty and not a c2 store. Initialize a store here anyway?`,
+          false,
+        )
+      ) {
+        console.log(`Keeping ${current}.`);
+        return current;
+      }
+      break;
+  }
+
+  await initStore(paths, new Date());
+  return canonicalRoot(paths.root);
+}
+
 export function registerSetup(program: Command): void {
   program
     .command("setup")
@@ -65,9 +120,11 @@ export function registerSetup(program: Command): void {
         console.log(`Invalid date "${endInput}", keeping previous value.`);
       }
 
-      await ensureDirs();
+      cfg.data_dir = await chooseDataDir(cfg.data_dir);
+
       await saveConfig(cfg);
-      console.log(`\nConfig written to ${join(configDir(), "config.json")}`);
+      console.log(`\nConfig written to ${join(configDir(), "config.json")} (mode 600)`);
+      console.log(`Data directory: ${pathsFor(cfg.data_dir).root}`);
 
       if (!cfg.goal.start_date || !cfg.goal.end_date) {
         console.log(