@richhaase/c2 0.3.3 → 0.4.0

package/src/notes.ts

@@ -0,0 +1,270 @@
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { isValidYMD } from "./models.ts";
+import type { DataPaths } from "./paths.ts";
+
+export const NOTE_TYPES = ["subjective", "observation", "lesson"] as const;
+export type NoteType = (typeof NOTE_TYPES)[number];
+
+export const NOTE_AUTHORS = ["athlete", "coach"] as const;
+export type NoteAuthor = (typeof NOTE_AUTHORS)[number];
+
+export interface NoteRecord {
+  id: string;
+  date: string;
+  type: NoteType;
+  workout_id?: number;
+  tags?: string[];
+  body: string;
+  author: NoteAuthor;
+}
+
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+
+export function ulid(now: Date): string {
+  let ms = now.getTime();
+  let time = "";
+  for (let i = 0; i < 10; i++) {
+    time = CROCKFORD[ms % 32] + time;
+    ms = Math.floor(ms / 32);
+  }
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  let rand = "";
+  for (const b of bytes) {
+    rand += CROCKFORD[b % 32];
+  }
+  return time + rand;
+}
+
+export function localISO(d: Date): string {
+  const pad = (n: number, width = 2) => String(Math.abs(n)).padStart(width, "0");
+  const offsetMinutes = -d.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const offset = `${sign}${pad(Math.floor(Math.abs(offsetMinutes) / 60))}:${pad(Math.abs(offsetMinutes) % 60)}`;
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}${offset}`;
+}
+
+export function serializeNote(note: NoteRecord): string {
+  const ordered: Record<string, unknown> = { id: note.id, date: note.date, type: note.type };
+  if (note.workout_id != null) ordered.workout_id = note.workout_id;
+  if (note.tags != null && note.tags.length > 0) ordered.tags = note.tags;
+  ordered.body = note.body;
+  ordered.author = note.author;
+  return JSON.stringify(ordered);
+}
+
+export function isNoteShaped(parsed: unknown): parsed is NoteRecord {
+  const note = parsed as NoteRecord;
+  return (
+    typeof note?.id === "string" &&
+    typeof note?.date === "string" &&
+    typeof note?.body === "string" &&
+    (NOTE_TYPES as readonly string[]).includes(note?.type) &&
+    (NOTE_AUTHORS as readonly string[]).includes(note?.author) &&
+    /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/.test(note.date) &&
+    isValidYMD(note.date.slice(0, 10)) &&
+    !Number.isNaN(new Date(note.date).getTime()) &&
+    (note.workout_id === undefined ||
+      (typeof note.workout_id === "number" && Number.isFinite(note.workout_id))) &&
+    (note.tags === undefined ||
+      (Array.isArray(note.tags) && note.tags.every((t) => typeof t === "string")))
+  );
+}
+
+function parseNote(raw: string): NoteRecord | null {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return isNoteShaped(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function compareNotes(a: NoteRecord, b: NoteRecord): number {
+  const aMs = new Date(a.date).getTime();
+  const bMs = new Date(b.date).getTime();
+  if (aMs !== bMs) return aMs < bMs ? -1 : 1;
+  if (a.id !== b.id) return a.id < b.id ? -1 : 1;
+  return 0;
+}
+
+export async function writeNote(paths: DataPaths, note: NoteRecord): Promise<void> {
+  await mkdir(paths.notesDir, { recursive: true });
+  await writeFile(join(paths.notesDir, `${note.id}.json`), `${serializeNote(note)}\n`, "utf-8");
+}
+
+interface LooseEntry {
+  note: NoteRecord;
+  file: string;
+}
+
+async function readLooseEntries(paths: DataPaths): Promise<LooseEntry[]> {
+  const entries: LooseEntry[] = [];
+  let files: string[];
+  try {
+    files = await readdir(paths.notesDir);
+  } catch {
+    return entries;
+  }
+  for (const f of files.sort()) {
+    if (!f.endsWith(".json")) continue;
+    try {
+      const note = parseNote(await readFile(join(paths.notesDir, f), "utf-8"));
+      if (note != null) entries.push({ note, file: f });
+    } catch {}
+  }
+  return entries;
+}
+
+async function readLooseNotes(paths: DataPaths): Promise<Map<string, NoteRecord>> {
+  const notes = new Map<string, NoteRecord>();
+  for (const entry of await readLooseEntries(paths)) {
+    notes.set(entry.note.id, entry.note);
+  }
+  return notes;
+}
+
+async function readArchivedNotes(paths: DataPaths): Promise<Map<string, NoteRecord>> {
+  const notes = new Map<string, NoteRecord>();
+  let files: string[];
+  try {
+    files = await readdir(paths.archiveDir);
+  } catch {
+    return notes;
+  }
+  for (const f of files) {
+    if (!f.endsWith(".jsonl")) continue;
+    let text: string;
+    try {
+      text = await readFile(join(paths.archiveDir, f), "utf-8");
+    } catch {
+      continue;
+    }
+    for (const line of text.split("\n")) {
+      if (line.trim() === "") continue;
+      const note = parseNote(line);
+      if (note != null && !notes.has(note.id)) notes.set(note.id, note);
+    }
+  }
+  return notes;
+}
+
+export async function readAllNotes(paths: DataPaths): Promise<NoteRecord[]> {
+  const archived = await readArchivedNotes(paths);
+  const loose = await readLooseNotes(paths);
+  for (const [id, note] of loose) {
+    archived.set(id, note);
+  }
+  return [...archived.values()].sort(compareNotes);
+}
+
+export interface NoteFilter {
+  type?: string;
+  since?: string;
+  workoutId?: number;
+}
+
+export function filterNotes(notes: NoteRecord[], filter: NoteFilter): NoteRecord[] {
+  return notes.filter((n) => {
+    if (filter.type && n.type !== filter.type) return false;
+    if (filter.since && n.date.slice(0, 10) < filter.since) return false;
+    if (filter.workoutId != null && n.workout_id !== filter.workoutId) return false;
+    return true;
+  });
+}
+
+const COMPACT_AGE_DAYS = 7;
+
+async function readArchiveYear(
+  paths: DataPaths,
+  year: number,
+): Promise<{ notes: NoteRecord[]; safeToRewrite: boolean }> {
+  const notes: NoteRecord[] = [];
+  let text: string;
+  try {
+    text = await readFile(paths.archiveFile(year), "utf-8");
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code;
+    return { notes, safeToRewrite: code === "ENOENT" };
+  }
+  const seen = new Set<string>();
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    const note = parseNote(line);
+    if (note == null) return { notes, safeToRewrite: false };
+    if (seen.has(note.id)) return { notes, safeToRewrite: false };
+    seen.add(note.id);
+    notes.push(note);
+  }
+  return { notes, safeToRewrite: true };
+}
+
+export interface CompactResult {
+  archived: number;
+  years: number[];
+  skippedYears: number[];
+}
+
+export async function compactNotes(paths: DataPaths, now: Date): Promise<CompactResult> {
+  const cutoff = new Date(now);
+  cutoff.setDate(cutoff.getDate() - COMPACT_AGE_DAYS);
+  const cutoffMs = cutoff.getTime();
+
+  const entries = await readLooseEntries(paths);
+  const deduped = new Map<string, NoteRecord>();
+  const contentById = new Map<string, string>();
+  const divergent = new Set<string>();
+  for (const e of entries) {
+    const content = serializeNote(e.note);
+    const prior = contentById.get(e.note.id);
+    if (prior != null && prior !== content) divergent.add(e.note.id);
+    contentById.set(e.note.id, content);
+    deduped.set(e.note.id, e.note);
+  }
+  const eligible = [...deduped.values()].filter(
+    (n) => !divergent.has(n.id) && new Date(n.date).getTime() < cutoffMs,
+  );
+  if (eligible.length === 0) return { archived: 0, years: [], skippedYears: [] };
+
+  const byYear = new Map<number, NoteRecord[]>();
+  for (const note of eligible) {
+    const year = Number(note.date.slice(0, 4));
+    if (!byYear.has(year)) byYear.set(year, []);
+    byYear.get(year)!.push(note);
+  }
+
+  await mkdir(paths.archiveDir, { recursive: true });
+  let archivedCount = 0;
+  const years: number[] = [];
+  const skippedYears: number[] = [];
+  for (const [year, notes] of byYear) {
+    const existing = await readArchiveYear(paths, year);
+    if (!existing.safeToRewrite) {
+      skippedYears.push(year);
+      continue;
+    }
+    const merged = new Map<string, NoteRecord>();
+    for (const n of existing.notes) merged.set(n.id, n);
+    for (const n of notes) merged.set(n.id, n);
+    const lines = [...merged.values()].sort(compareNotes).map(serializeNote);
+    try {
+      await writeFile(paths.archiveFile(year), `${lines.join("\n")}\n`, "utf-8");
+    } catch {
+      skippedYears.push(year);
+      continue;
+    }
+    const archivedIds = new Set(notes.map((n) => n.id));
+    for (const e of entries) {
+      if (archivedIds.has(e.note.id)) {
+        try {
+          await rm(join(paths.notesDir, e.file), { force: true });
+        } catch {}
+      }
+    }
+    archivedCount += notes.length;
+    years.push(year);
+  }
+
+  return { archived: archivedCount, years: years.sort(), skippedYears: skippedYears.sort() };
+}

package/src/paths.test.ts

@@ -0,0 +1,47 @@
+import { expect, test } from "bun:test";
+import { chmod, mkdir, mkdtemp } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { canonicalRoot, expandTilde, pathsFor } from "./paths.ts";
+
+test("expandTilde resolves home shorthand", () => {
+  expect(expandTilde("~")).toBe(homedir());
+  expect(expandTilde("~/Documents/kb")).toBe(join(homedir(), "Documents", "kb"));
+  expect(expandTilde("/absolute/path")).toBe("/absolute/path");
+});
+
+test("pathsFor derives every path from the root", () => {
+  const p = pathsFor("/tmp/c2-store");
+  expect(p.root).toBe("/tmp/c2-store");
+  expect(p.meta).toBe("/tmp/c2-store/meta.json");
+  expect(p.workouts).toBe("/tmp/c2-store/workouts.jsonl");
+  expect(p.strokeFile(42)).toBe("/tmp/c2-store/strokes/42.jsonl");
+  expect(p.archiveFile(2026)).toBe("/tmp/c2-store/notes/archive/2026.jsonl");
+  expect(p.narrativeFile("2026-07-05")).toBe("/tmp/c2-store/reports/2026-07-05.md");
+});
+
+test("pathsFor expands tilde roots", () => {
+  const p = pathsFor("~/kb/c2");
+  expect(p.root).toBe(join(homedir(), "kb", "c2"));
+});
+
+test("canonicalRoot keeps missing tail components", async () => {
+  const base = await mkdtemp(join(tmpdir(), "c2-canon-"));
+  const target = join(base, "a", "b", "c");
+  const out = await canonicalRoot(target);
+  expect(out.endsWith(join("a", "b", "c"))).toBe(true);
+});
+
+test("canonicalRoot preserves the full path when an ancestor is unreadable", async () => {
+  const base = await mkdtemp(join(tmpdir(), "c2-canon-eacces-"));
+  const locked = join(base, "locked");
+  await mkdir(locked);
+  await chmod(locked, 0o000);
+  try {
+    const target = join(locked, "x", "y");
+    const out = await canonicalRoot(target);
+    expect(out.endsWith(join("locked", "x", "y"))).toBe(true);
+  } finally {
+    await chmod(locked, 0o755);
+  }
+});

package/src/paths.ts

@@ -0,0 +1,66 @@
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import type { Config } from "./config.ts";
+
+export interface DataPaths {
+  root: string;
+  meta: string;
+  workouts: string;
+  strokesDir: string;
+  strokeFile(id: number): string;
+  notesDir: string;
+  archiveDir: string;
+  archiveFile(year: number): string;
+  plan: string;
+  playbook: string;
+  reportsDir: string;
+  narrativeFile(date: string): string;
+}
+
+export function expandTilde(p: string): string {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return join(homedir(), p.slice(2));
+  return p;
+}
+
+export function pathsFor(root: string): DataPaths {
+  const abs = resolve(expandTilde(root));
+  return {
+    root: abs,
+    meta: join(abs, "meta.json"),
+    workouts: join(abs, "workouts.jsonl"),
+    strokesDir: join(abs, "strokes"),
+    strokeFile: (id: number) => join(abs, "strokes", `${id}.jsonl`),
+    notesDir: join(abs, "notes"),
+    archiveDir: join(abs, "notes", "archive"),
+    archiveFile: (year: number) => join(abs, "notes", "archive", `${year}.jsonl`),
+    plan: join(abs, "plan.md"),
+    playbook: join(abs, "playbook.md"),
+    reportsDir: join(abs, "reports"),
+    narrativeFile: (date: string) => join(abs, "reports", `${date}.md`),
+  };
+}
+
+export function dataPaths(cfg: Config): DataPaths {
+  return pathsFor(cfg.data_dir);
+}
+
+export async function canonicalRoot(p: string): Promise<string> {
+  let base = resolve(expandTilde(p));
+  const rest: string[] = [];
+  for (;;) {
+    try {
+      const real = await realpath(base);
+      return rest.length > 0 ? join(real, ...rest) : real;
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        return rest.length > 0 ? join(base, ...rest) : base;
+      }
+      rest.unshift(basename(base));
+      const parent = dirname(base);
+      if (parent === base) return resolve(expandTilde(p));
+      base = parent;
+    }
+  }
+}

package/src/stats.ts

@@ -1,7 +1,7 @@
 import type { Config } from "./config.ts";
 import { parseGoalDate } from "./config.ts";
 import type { Workout } from "./models.ts";
-import { calendarDay, pace500mSeconds, parsedDate } from "./models.ts";
+import { calendarDay, formatSeconds, pace500mSeconds, parsedDate } from "./models.ts";
 
 export interface WeekSummary {
   weekStart: Date;
@@ -105,6 +105,58 @@ export function buildWeekSummaries(workouts: Workout[], now: Date, weeks: number
   return summaries;
 }
 
+export interface RecentWeek {
+  weekStart: Date;
+  meters: number;
+  sessions: number;
+}
+
+export function recentWeeks(workouts: Workout[], now: Date, count: number): RecentWeek[] {
+  const out: RecentWeek[] = [];
+  for (let i = 0; i < count; i++) {
+    const weekStart = mondayOf(now);
+    weekStart.setDate(weekStart.getDate() - i * 7);
+    const weekEnd = new Date(weekStart);
+    weekEnd.setDate(weekEnd.getDate() + 7);
+    const weekWorkouts = workoutsInRange(workouts, weekStart, weekEnd);
+    out.push({
+      weekStart,
+      meters: weekWorkouts.reduce((sum, w) => sum + w.distance, 0),
+      sessions: new Set(weekWorkouts.map(calendarDay)).size,
+    });
+  }
+  return out;
+}
+
+export interface WeekSummaryData {
+  week_start: string;
+  meters: number;
+  sessions: number;
+  avg_pace_500m_seconds: number | null;
+  avg_pace_500m: string | null;
+  avg_spm: number | null;
+  avg_hr: number | null;
+}
+
+export function localYMD(d: Date): string {
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${d.getFullYear()}-${mm}-${dd}`;
+}
+
+export function weekSummaryData(ws: WeekSummary): WeekSummaryData {
+  const avgPace = ws.paceCount > 0 ? ws.paceSum / ws.paceCount : null;
+  return {
+    week_start: localYMD(ws.weekStart),
+    meters: ws.meters,
+    sessions: ws.sessions,
+    avg_pace_500m_seconds: avgPace != null ? Math.round(avgPace * 10) / 10 : null,
+    avg_pace_500m: avgPace != null ? formatSeconds(avgPace) : null,
+    avg_spm: ws.spmCount > 0 ? Math.round((ws.spmSum / ws.spmCount) * 10) / 10 : null,
+    avg_hr: ws.hrCount > 0 ? Math.round(ws.hrSum / ws.hrCount) : null,
+  };
+}
+
 export function computeGoalProgress(workouts: Workout[], cfg: Config, now?: Date): GoalProgress {
   const target = cfg.goal.target_meters;
   const start = parseGoalDate(cfg.goal.start_date);

package/src/storage.ts

@@ -1,75 +1,113 @@
 import { appendFile, readFile, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { dataDir } from "./config.ts";
 import type { StrokeData, Workout } from "./models.ts";
+import type { DataPaths } from "./paths.ts";
 
-function workoutsPath(): string {
-  return join(dataDir(), "workouts.jsonl");
+export interface StoreMeta {
+  schema_version: number;
+  created: string;
+  last_sync?: string;
 }
 
-function strokesPath(workoutId: number): string {
-  return join(dataDir(), "strokes", `${workoutId}.jsonl`);
-}
+export const SCHEMA_VERSION = 1;
 
-export async function readWorkouts(): Promise<Workout[]> {
+export async function readWorkouts(paths: DataPaths): Promise<Workout[]> {
   try {
-    const text = await readFile(workoutsPath(), "utf-8");
+    const text = await readFile(paths.workouts, "utf-8");
     return text
       .split("\n")
       .filter((line) => line.trim() !== "")
       .map((line) => JSON.parse(line) as Workout);
   } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR") return [];
     throw err;
   }
 }
 
-export async function appendWorkouts(newWorkouts: Workout[]): Promise<number> {
-  const existing = await readWorkouts();
+export async function appendWorkouts(paths: DataPaths, newWorkouts: Workout[]): Promise<number> {
+  const existing = await readWorkouts(paths);
   const seen = new Set(existing.map((w) => w.id));
 
   const toWrite = newWorkouts.filter((w) => !seen.has(w.id));
   if (toWrite.length === 0) return 0;
 
   const lines = `${toWrite.map((w) => JSON.stringify(w)).join("\n")}\n`;
-  await appendFile(workoutsPath(), lines, "utf-8");
+  await appendFile(paths.workouts, lines, "utf-8");
   return toWrite.length;
 }
 
-export async function workoutCount(): Promise<number> {
+export async function workoutCount(paths: DataPaths): Promise<number> {
   try {
-    const text = await readFile(workoutsPath(), "utf-8");
+    const text = await readFile(paths.workouts, "utf-8");
     return text.split("\n").filter((line) => line.trim() !== "").length;
   } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") return 0;
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR") return 0;
     throw err;
   }
 }
 
-export async function hasStrokeData(workoutId: number): Promise<boolean> {
+export async function hasStrokeData(paths: DataPaths, workoutId: number): Promise<boolean> {
   try {
-    await stat(strokesPath(workoutId));
+    await stat(paths.strokeFile(workoutId));
     return true;
   } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") return false;
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR") return false;
     throw err;
   }
 }
 
-export async function writeStrokeData(workoutId: number, strokes: StrokeData[]): Promise<void> {
+export async function writeStrokeData(
+  paths: DataPaths,
+  workoutId: number,
+  strokes: StrokeData[],
+): Promise<void> {
   const lines = `${strokes.map((s) => JSON.stringify(s)).join("\n")}\n`;
-  await writeFile(strokesPath(workoutId), lines, "utf-8");
+  await writeFile(paths.strokeFile(workoutId), lines, "utf-8");
 }
 
-export async function readStrokeData(workoutId: number): Promise<StrokeData[]> {
+export async function readStrokeData(paths: DataPaths, workoutId: number): Promise<StrokeData[]> {
+  let text: string;
   try {
-    const text = await readFile(strokesPath(workoutId), "utf-8");
-    return text
-      .split("\n")
-      .filter((line) => line.trim() !== "")
-      .map((line) => JSON.parse(line) as StrokeData);
+    text = await readFile(paths.strokeFile(workoutId), "utf-8");
   } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "ENOENT" || code === "ENOTDIR") return [];
     throw err;
   }
+  const strokes: StrokeData[] = [];
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    try {
+      const parsed = JSON.parse(line) as unknown;
+      if (parsed != null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        strokes.push(parsed as StrokeData);
+      }
+    } catch {}
+  }
+  return strokes;
+}
+
+export async function readMeta(paths: DataPaths): Promise<StoreMeta | null> {
+  let text: string;
+  try {
+    text = await readFile(paths.meta, "utf-8");
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code !== "ENOENT" && code !== "ENOTDIR") {
+      console.error(`Warning: ${paths.meta} is unreadable and will be ignored.`);
+    }
+    return null;
+  }
+  try {
+    return JSON.parse(text) as StoreMeta;
+  } catch {
+    console.error(`Warning: ${paths.meta} is corrupt and will be ignored.`);
+    return null;
+  }
+}
+
+export async function writeMeta(paths: DataPaths, meta: StoreMeta): Promise<void> {
+  await writeFile(paths.meta, `${JSON.stringify(meta, null, 2)}\n`, "utf-8");
 }