@drakulavich/oura-cli 0.5.0 → 0.5.1

package/dist/index.js

@@ -1105,9 +1105,9 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 
 // src/commands/login.ts
 init_source();
-import { writeFileSync, chmodSync, mkdirSync } from "fs";
-import { resolve, dirname } from "path";
-import { homedir } from "os";
+import { writeFileSync, chmodSync as chmodSync2, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve3, dirname as dirname2 } from "path";
+import { homedir as homedir3 } from "os";
 
 // src/lib/errors.ts
 init_source();
@@ -1144,8 +1144,8 @@ function redactSecrets(s) {
 }
 function formatError(err, format) {
   const code = err instanceof CliError ? err.code : "UNKNOWN";
-  const message = err instanceof Error ? err.message : String(err);
-  const hint = err instanceof CliError ? err.hint : undefined;
+  const message = redactSecrets(err instanceof Error ? err.message : String(err));
+  const hint = err instanceof CliError && err.hint ? redactSecrets(err.hint) : undefined;
   if (format === "json") {
     return {
       kind: "json",
@@ -1171,110 +1171,407 @@ var commonArgs = {
   "no-color": { type: "boolean", default: false, description: "Disable ANSI colors (also honors NO_COLOR env)" }
 };
 
-// src/commands/login.ts
-async function readHiddenToken(input, output) {
-  if (!input.isTTY || !input.setRawMode) {
-    throw new CliError("BAD_ARGS", "Interactive login requires a terminal.", "Use `oura-cli login --token` for non-interactive use.");
+// src/commands/run-command.ts
+init_source();
+
+// src/db/open.ts
+import { Database, SQLiteError } from "bun:sqlite";
+import { resolve, dirname } from "path";
+import { homedir } from "os";
+import { chmodSync, existsSync, mkdirSync } from "fs";
+
+// src/db/migrations.ts
+var MIGRATIONS = [
+  {
+    version: 1,
+    sql: `
+CREATE TABLE IF NOT EXISTS daily_sleep (
+    id TEXT PRIMARY KEY,
+    day TEXT UNIQUE,
+    score INTEGER,
+    contributors TEXT,
+    timestamp TEXT
+);
+CREATE TABLE IF NOT EXISTS daily_readiness (
+    id TEXT PRIMARY KEY,
+    day TEXT UNIQUE,
+    score INTEGER,
+    contributors TEXT,
+    temperature_deviation REAL,
+    temperature_trend_deviation REAL,
+    timestamp TEXT
+);
+CREATE TABLE IF NOT EXISTS daily_activity (
+    id TEXT PRIMARY KEY,
+    day TEXT UNIQUE,
+    score INTEGER,
+    active_calories INTEGER,
+    steps INTEGER,
+    equivalent_walking_distance REAL,
+    high_activity_time INTEGER,
+    medium_activity_time INTEGER,
+    low_activity_time INTEGER,
+    sedentary_time INTEGER,
+    total_calories INTEGER,
+    target_calories INTEGER,
+    contributors TEXT,
+    timestamp TEXT
+);
+CREATE TABLE IF NOT EXISTS daily_spo2 (
+    id TEXT PRIMARY KEY,
+    day TEXT UNIQUE,
+    spo2_average REAL,
+    breathing_disturbance_index REAL
+);
+CREATE TABLE IF NOT EXISTS daily_stress (
+    id TEXT PRIMARY KEY,
+    day TEXT UNIQUE,
+    day_summary TEXT,
+    recovery_high INTEGER,
+    stress_high INTEGER
+);
+CREATE TABLE IF NOT EXISTS heartrate (
+    timestamp TEXT,
+    bpm INTEGER,
+    source TEXT,
+    day TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_heartrate_ts ON heartrate(timestamp);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_heartrate_unique ON heartrate(timestamp, source);
+CREATE INDEX IF NOT EXISTS idx_heartrate_day ON heartrate(day);
+CREATE TABLE IF NOT EXISTS vo2max (
+    id TEXT PRIMARY KEY,
+    day TEXT UNIQUE,
+    vo2_max REAL,
+    timestamp TEXT
+);
+CREATE TABLE IF NOT EXISTS cardiovascular_age (
+    id TEXT PRIMARY KEY,
+    day TEXT UNIQUE,
+    vascular_age INTEGER
+);
+CREATE TABLE IF NOT EXISTS workouts (
+    id TEXT PRIMARY KEY,
+    day TEXT,
+    activity TEXT,
+    calories REAL,
+    distance REAL,
+    start_datetime TEXT,
+    end_datetime TEXT,
+    intensity TEXT,
+    label TEXT,
+    source TEXT
+);
+CREATE TABLE IF NOT EXISTS sleep_model (
+    id TEXT PRIMARY KEY,
+    day TEXT,
+    average_breath REAL,
+    average_heart_rate REAL,
+    average_hrv REAL,
+    awake_time INTEGER,
+    bedtime_end TEXT,
+    bedtime_start TEXT,
+    deep_sleep_duration INTEGER,
+    efficiency INTEGER,
+    latency INTEGER,
+    light_sleep_duration INTEGER,
+    lowest_heart_rate INTEGER,
+    period INTEGER,
+    rem_sleep_duration INTEGER,
+    restless_periods INTEGER,
+    time_in_bed INTEGER,
+    total_sleep_duration INTEGER,
+    type TEXT
+);
+    `
+  },
+  {
+    version: 2,
+    sql: `
+CREATE VIEW IF NOT EXISTS v_weekly_sleep AS
+    SELECT strftime('%Y-W%W', day) as week, ROUND(AVG(score),1) as avg_score, COUNT(*) as days
+    FROM daily_sleep WHERE score IS NOT NULL GROUP BY week ORDER BY week DESC;
+
+CREATE VIEW IF NOT EXISTS v_weekly_readiness AS
+    SELECT strftime('%Y-W%W', day) as week, ROUND(AVG(score),1) as avg_score,
+        ROUND(AVG(temperature_deviation),2) as avg_temp_dev, COUNT(*) as days
+    FROM daily_readiness WHERE score IS NOT NULL GROUP BY week ORDER BY week DESC;
+
+CREATE VIEW IF NOT EXISTS v_weekly_activity AS
+    SELECT strftime('%Y-W%W', day) as week, ROUND(AVG(score),1) as avg_score,
+        SUM(steps) as total_steps, SUM(active_calories) as total_active_cal, COUNT(*) as days
+    FROM daily_activity WHERE score IS NOT NULL GROUP BY week ORDER BY week DESC;
+
+CREATE VIEW IF NOT EXISTS v_sleep_detail AS
+    SELECT day, ROUND(total_sleep_duration/3600.0,1) as sleep_hours,
+        ROUND(deep_sleep_duration/3600.0,1) as deep_hours,
+        ROUND(rem_sleep_duration/3600.0,1) as rem_hours,
+        average_hrv, average_heart_rate as avg_hr, lowest_heart_rate as lowest_hr, efficiency
+    FROM sleep_model ORDER BY day DESC;
+    `
   }
-  output.write("Paste your token (input hidden): ");
-  input.setRawMode(true);
-  input.resume();
-  return new Promise((resolve, reject) => {
-    let token = "";
-    const finish = () => {
-      input.off("data", onData);
-      input.setRawMode?.(false);
-      input.pause();
-      output.write(`
-`);
-    };
-    const onData = (chunk) => {
-      for (const char of chunk.toString("utf8")) {
-        if (char === "\r" || char === `
-`) {
-          finish();
-          resolve(token);
-          return;
-        }
-        if (char === "\x03" || char === "\x04") {
-          finish();
-          reject(new CliError("BAD_ARGS", "Login cancelled."));
-          return;
-        }
-        if (char === "\b" || char === "\x7F") {
-          token = token.slice(0, -1);
-        } else if (char >= " ") {
-          token += char;
-        }
-      }
-    };
-    input.on("data", onData);
-  });
+];
+
+// src/db/open.ts
+var DB_HINT = "Check the path in --db / OURA_DB_PATH and that the file is a SQLite database oura-cli created.";
+var BUSY_HINT = "Another oura-cli process is using this database; wait for it to finish and retry.";
+var BUSY_TIMEOUT_MS = 5000;
+function dbError(what, err) {
+  const detail = err instanceof Error ? err.message : String(err);
+  const hint = /database is locked|SQLITE_BUSY/i.test(detail) ? BUSY_HINT : DB_HINT;
+  return new CliError("DB_ERROR", `${what}: ${detail}`, hint);
 }
-function writeToken(path, token) {
-  const trimmed = token.trim();
-  if (trimmed.length === 0) {
-    throw new CliError("BAD_ARGS", "Token cannot be empty.");
-  }
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, trimmed, { encoding: "utf-8" });
-  if (process.platform !== "win32") {
-    chmodSync(path, 384);
+function asDbError(err) {
+  return err instanceof SQLiteError ? dbError("Database query failed", err) : undefined;
+}
+function getDbPath(explicit) {
+  if (explicit)
+    return explicit;
+  if (process.env.OURA_DB_PATH)
+    return process.env.OURA_DB_PATH;
+  return resolve(homedir(), ".oura-cli", "oura.db");
+}
+function openDatabase(explicit) {
+  const dbPath = getDbPath(explicit);
+  try {
+    const onDisk = dbPath !== ":memory:";
+    const isNew = onDisk && !existsSync(dbPath);
+    if (onDisk)
+      mkdirSync(dirname(dbPath), { recursive: true, mode: 448 });
+    const db = new Database(dbPath);
+    if (isNew)
+      chmodSync(dbPath, 384);
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+    const mode = db.query("PRAGMA journal_mode").get();
+    if (mode.journal_mode !== "wal")
+      db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    return db;
+  } catch (err) {
+    throw dbError(`Cannot open database ${dbPath}`, err);
   }
 }
-var loginCommand = defineCommand({
-  meta: { name: "login", description: "Save an Oura Personal Access Token for future commands." },
-  args: {
-    token: { type: "string", description: "Pass token non-interactively (e.g. for scripts)" },
-    path: { type: "string", description: "Where to save the token (default: $OURA_TOKEN_PATH or ~/.oura-token)" },
-    "no-color": commonArgs["no-color"]
-  },
-  async run({ args }) {
-    try {
-      if (args["no-color"] || process.env.NO_COLOR) {
-        await Promise.resolve().then(() => init_source());
-        source_default.level = 0;
-      }
-      const target = args.path ?? process.env.OURA_TOKEN_PATH ?? resolve(homedir(), ".oura-token");
-      let token = args.token;
-      if (!token) {
-        console.log("Get a Personal Access Token at https://cloud.ouraring.com/personal-access-tokens");
-        token = await readHiddenToken(process.stdin, process.stdout);
+function schemaVersion(db) {
+  db.exec("CREATE TABLE IF NOT EXISTS _schema_version (version INTEGER NOT NULL)");
+  const row = db.query("SELECT MAX(version) AS v FROM _schema_version").get();
+  return row?.v ?? 0;
+}
+function ensureSchema(db, migrations = MIGRATIONS) {
+  try {
+    const current = schemaVersion(db);
+    for (const m of migrations) {
+      if (m.version > current) {
+        db.exec(m.sql);
+        db.query("INSERT INTO _schema_version (version) VALUES (?)").run(m.version);
       }
-      writeToken(target, token);
-      console.log(source_default.green(`Saved to ${target}`));
-    } catch (err) {
-      emitError(err, "table");
-      process.exit(exitCodeFor(err));
     }
+  } catch (err) {
+    throw dbError("Schema migration failed", err);
   }
-});
-
-// src/lib/time.ts
-function nowUtc() {
-  return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-function formatLocal(utcStr, timezone) {
-  const dt = new Date(utcStr);
-  const parts = new Intl.DateTimeFormat("sv-SE", {
-    timeZone: 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 ?? "";
-  return `${get("year")}-${get("month")}-${get("day")} ${get("hour")}:${get("minute")}`;
-}
-function formatLocalDate(utcStr, timezone) {
-  return formatLocal(utcStr, timezone).split(" ")[0];
 }
-function todayLocal(timezone) {
-  return formatLocalDate(nowUtc(), timezone);
+
+// src/api/token.ts
+import { readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
+function defaultTokenPath() {
+  return process.env.OURA_TOKEN_PATH ?? resolve2(homedir2(), ".oura-token");
 }
-function getTimezoneOffsetMs(utc, tz) {
+function resolveToken(explicit, tokenPath) {
+  if (explicit)
+    return { token: explicit.trim(), source: "--token" };
+  if (process.env.OURA_TOKEN)
+    return { token: process.env.OURA_TOKEN.trim(), source: "OURA_TOKEN" };
+  const path = tokenPath ?? defaultTokenPath();
+  try {
+    return { token: readFileSync(path, "utf-8").trim(), source: path };
+  } catch {
+    return { token: null, source: path };
+  }
+}
+
+// src/api/client.ts
+var BASE_URL = "https://api.ouraring.com/v2/usercollection";
+var MAX_PAGES = 1e4;
+
+class OuraClient {
+  token;
+  constructor(options = {}) {
+    const { token, source } = resolveToken(options.token, options.tokenPath);
+    if (!token) {
+      throw new CliError("TOKEN_MISSING", `No Oura access token at ${source}.`, "Run `oura-cli login` or set OURA_TOKEN.");
+    }
+    if (/\s/.test(token)) {
+      throw new CliError("TOKEN_INVALID", `The token from ${source} contains whitespace or a line break; a token is a single line.`, "Fix the file or variable, or run `oura-cli login` again.");
+    }
+    this.token = token;
+  }
+  async fetch(endpoint, query) {
+    const rows = [];
+    const seenTokens = new Set;
+    let nextToken = null;
+    do {
+      if (seenTokens.size >= MAX_PAGES) {
+        throw new CliError("API_ERROR", `Oura API returned more than ${MAX_PAGES} pages for ${endpoint}; stopping.`);
+      }
+      const params = new URLSearchParams(query);
+      if (nextToken)
+        params.set("next_token", nextToken);
+      const page = await this.getPage(`${BASE_URL}/${endpoint}?${params}`);
+      for (const row of page.data)
+        rows.push(row);
+      nextToken = page.next_token;
+      if (nextToken && seenTokens.has(nextToken)) {
+        throw new CliError("API_ERROR", `Oura API repeated pagination token for ${endpoint}; stopping to avoid a loop.`);
+      }
+      if (nextToken)
+        seenTokens.add(nextToken);
+    } while (nextToken);
+    return rows;
+  }
+  async getPage(url) {
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${this.token}` }
+    });
+    if (!response.ok) {
+      const rawBody = await response.text();
+      const redacted = redactSecrets(rawBody);
+      const body = redacted.length > 200 ? redacted.slice(0, 200) + "\u2026 (truncated)" : redacted;
+      if (response.status === 401 || response.status === 403) {
+        throw new CliError("TOKEN_INVALID", `Oura API ${response.status}: ${body}`);
+      }
+      throw new CliError("API_ERROR", `Oura API ${response.status}: ${body}`);
+    }
+    let json;
+    try {
+      json = await response.json();
+    } catch {
+      throw new CliError("API_ERROR", "Empty response body from Oura API.");
+    }
+    const body = json;
+    return { data: body.data ?? [], next_token: body.next_token ?? null };
+  }
+}
+
+// src/lib/argv-normalize.ts
+var GLOBAL_FLAGS_WITH_VALUE = new Set(["--format", "--token", "--db", "--tz"]);
+var GLOBAL_FLAGS_BOOLEAN = new Set(["--no-color"]);
+var SUBCOMMANDS = new Set([
+  "login",
+  "describe",
+  "healthcheck",
+  "doctor",
+  "manifest",
+  "fetch",
+  "sync",
+  "db",
+  "report"
+]);
+function normalizeArgv(argv) {
+  const [bun, script, ...rest] = argv;
+  const subIdx = rest.findIndex((a) => SUBCOMMANDS.has(a));
+  if (subIdx < 0)
+    return argv;
+  const before = rest.slice(0, subIdx);
+  const subcommandOnwards = rest.slice(subIdx);
+  const hoisted = [];
+  const leftover = [];
+  for (let i = 0;i < before.length; i++) {
+    const tok = before[i];
+    if (tok.includes("=")) {
+      const name = tok.slice(0, tok.indexOf("="));
+      if (GLOBAL_FLAGS_WITH_VALUE.has(name) || GLOBAL_FLAGS_BOOLEAN.has(name)) {
+        hoisted.push(tok);
+        continue;
+      }
+    }
+    if (GLOBAL_FLAGS_WITH_VALUE.has(tok)) {
+      hoisted.push(tok);
+      if (i + 1 < before.length) {
+        hoisted.push(before[i + 1]);
+        i++;
+      }
+      continue;
+    }
+    if (GLOBAL_FLAGS_BOOLEAN.has(tok)) {
+      hoisted.push(tok);
+      continue;
+    }
+    leftover.push(tok);
+  }
+  const dd = subcommandOnwards.indexOf("--");
+  if (dd >= 0) {
+    return [bun, script, ...leftover, ...subcommandOnwards.slice(0, dd), ...hoisted, ...subcommandOnwards.slice(dd)];
+  }
+  return [bun, script, ...leftover, ...subcommandOnwards, ...hoisted];
+}
+function isVersionRequest(rawArgs) {
+  for (let i = 0;i < rawArgs.length; i++) {
+    const tok = rawArgs[i];
+    if (SUBCOMMANDS.has(tok))
+      return false;
+    if (GLOBAL_FLAGS_WITH_VALUE.has(tok)) {
+      i++;
+      continue;
+    }
+    if (tok === "--version" || tok === "-v")
+      return true;
+  }
+  return false;
+}
+
+// src/lib/format-resolve.ts
+function resolveFormat({ explicit, isTty }) {
+  if (explicit === undefined)
+    return isTty ? "table" : "json";
+  if (explicit === "table" || explicit === "json")
+    return explicit;
+  throw new CliError("BAD_ARGS", `Unknown --format value: "${explicit}". Use "table" or "json".`);
+}
+function formatFromArgv(argv, isTty) {
+  let explicit;
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--format") {
+      explicit = argv[i + 1];
+      i++;
+    } else if (a.startsWith("--format="))
+      explicit = a.slice("--format=".length);
+    else if (GLOBAL_FLAGS_WITH_VALUE.has(a))
+      i++;
+  }
+  try {
+    return resolveFormat({ explicit, isTty });
+  } catch {
+    return isTty ? "table" : "json";
+  }
+}
+
+// src/lib/time.ts
+function nowUtc() {
+  return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function formatLocal(utcStr, timezone) {
+  const dt = new Date(utcStr);
+  const parts = new Intl.DateTimeFormat("sv-SE", {
+    timeZone: 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 ?? "";
+  return `${get("year")}-${get("month")}-${get("day")} ${get("hour")}:${get("minute")}`;
+}
+function formatLocalDate(utcStr, timezone) {
+  return formatLocal(utcStr, timezone).split(" ")[0];
+}
+function todayLocal(timezone) {
+  return formatLocalDate(nowUtc(), timezone);
+}
+function getTimezoneOffsetMs(utc, tz) {
   const tzPart = new Intl.DateTimeFormat("en-US", {
     timeZone: tz,
     timeZoneName: "longOffset"
@@ -1324,71 +1621,253 @@ function isCalendarDate(value) {
   return !Number.isNaN(ms) && new Date(ms).toISOString().slice(0, 10) === value;
 }
 
-// src/collections/types.ts
-function defineCollection(c) {
-  return c;
+// src/lib/validate.ts
+function assertCalendarDate(value, label) {
+  if (!isCalendarDate(value)) {
+    throw new CliError("BAD_ARGS", `${label} must be a real YYYY-MM-DD date, got "${value}".`);
+  }
+  return value;
+}
+function assertPositiveInt(value, label) {
+  const n = Number(value);
+  if (!/^\d+$/.test(value.trim()) || !Number.isSafeInteger(n) || n < 1) {
+    throw new CliError("BAD_ARGS", `${label} must be a positive integer, got "${value}".`);
+  }
+  return n;
+}
+function assertTimezone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: tz });
+    return tz;
+  } catch {
+    throw new CliError("BAD_ARGS", `Unknown timezone "${tz}".`, "Use an IANA name such as Europe/Berlin (env: OURA_TZ, flag: --tz).");
+  }
 }
 
-// src/collections/sleep.ts
-var sleep = defineCollection({
-  name: "sleep",
-  endpoint: "daily_sleep",
-  table: "daily_sleep",
-  description: "Daily sleep score and contributors",
-  conflict: "replace",
-  rangeParams: "date",
-  identity: [
-    { field: "id", description: "Oura record id" },
-    { field: "day", format: "date", description: "Date the record applies to (YYYY-MM-DD)" }
-  ],
-  columns: [
-    { name: "id", type: "TEXT", pk: true, pick: (r) => r.id },
-    { name: "day", type: "TEXT", unique: true, pick: (r) => r.day },
-    { name: "score", type: "INTEGER", pick: (r) => r.score },
-    { name: "contributors", type: "TEXT", pick: (r) => JSON.stringify(r.contributors) },
-    { name: "timestamp", type: "TEXT", pick: (r) => r.timestamp }
-  ]
-});
-
-// src/collections/readiness.ts
-var readiness = defineCollection({
-  name: "readiness",
-  endpoint: "daily_readiness",
-  table: "daily_readiness",
-  description: "Daily readiness score, contributors and temperature deviation",
-  conflict: "replace",
-  rangeParams: "date",
-  identity: [
-    { field: "id", description: "Oura record id" },
-    { field: "day", format: "date", description: "Date the record applies to (YYYY-MM-DD)" }
-  ],
-  columns: [
-    { name: "id", type: "TEXT", pk: true, pick: (r) => r.id },
-    { name: "day", type: "TEXT", unique: true, pick: (r) => r.day },
-    { name: "score", type: "INTEGER", pick: (r) => r.score },
-    { name: "contributors", type: "TEXT", pick: (r) => JSON.stringify(r.contributors) },
-    { name: "temperature_deviation", type: "REAL", pick: (r) => r.temperature_deviation },
-    { name: "temperature_trend_deviation", type: "REAL", pick: (r) => r.temperature_trend_deviation },
-    { name: "timestamp", type: "TEXT", pick: (r) => r.timestamp }
-  ]
-});
-
-// src/collections/activity.ts
-var activity = defineCollection({
-  name: "activity",
-  endpoint: "daily_activity",
-  table: "daily_activity",
-  description: "Daily activity score, steps, calories and activity-time buckets",
-  conflict: "replace",
-  rangeParams: "date",
-  identity: [
-    { field: "id", description: "Oura record id" },
-    { field: "day", format: "date", description: "Date the record applies to (YYYY-MM-DD)" }
-  ],
-  columns: [
-    { name: "id", type: "TEXT", pk: true, pick: (r) => r.id },
-    { name: "day", type: "TEXT", unique: true, pick: (r) => r.day },
-    { name: "score", type: "INTEGER", pick: (r) => r.score },
+// src/commands/run-command.ts
+var processIo = {
+  stdout: (s) => {
+    process.stdout.write(s + `
+`);
+  },
+  stderr: (s) => {
+    process.stderr.write(s + `
+`);
+  },
+  exit: (code) => process.exit(code),
+  isTty: process.stdout.isTTY === true
+};
+var camel = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+function assertKnownArgs(declared, args) {
+  const known = new Set(["_"]);
+  let positionals = 0;
+  for (const [name, def] of Object.entries(declared)) {
+    known.add(name);
+    known.add(camel(name));
+    if (name.startsWith("no-"))
+      known.add(name.slice(3));
+    for (const alias of [def.alias ?? []].flat())
+      known.add(alias);
+    if (def.type === "positional")
+      positionals++;
+  }
+  const unknown = Object.keys(args).filter((k) => !known.has(k));
+  if (unknown.length > 0) {
+    const flags = unknown.map((f) => f.length === 1 ? `-${f}` : `--${f}`).join(", ");
+    const hint = unknown.every((f) => f.length === 1) ? 'oura-cli has no single-letter flags; a value that starts with "-" must come after "--".' : "Run the command with --help to see its flags.";
+    throw new CliError("BAD_ARGS", `Unknown flag${unknown.length > 1 ? "s" : ""}: ${flags}.`, hint);
+  }
+  const extra = (args._ ?? []).slice(positionals);
+  if (extra.length > 0) {
+    throw new CliError("BAD_ARGS", `Unexpected argument${extra.length > 1 ? "s" : ""}: ${extra.join(" ")}.`, "Run the command with --help to see its arguments.");
+  }
+}
+async function execute(def, args, io = processIo) {
+  if (args["no-color"] === true || args.color === false || process.env.NO_COLOR)
+    source_default.level = 0;
+  let db;
+  let format = io.isTty ? "table" : "json";
+  let exitCode = 0;
+  try {
+    format = resolveFormat({ explicit: args.format, isTty: io.isTty });
+    assertKnownArgs({ ...commonArgs, ...def.args ?? {} }, args);
+    const outputFormat = def.jsonOnly ? "json" : format;
+    const tz = assertTimezone(args.tz ?? resolveDefaultTimezone());
+    const ctx = { format: outputFormat, tz, today: today(tz) };
+    if (def.needs?.db) {
+      db = openDatabase(args.db);
+      ensureSchema(db);
+      ctx.db = db;
+    }
+    if (def.needs?.client) {
+      ctx.client = new OuraClient(args.token ? { token: args.token } : {});
+    }
+    const out = await def.run(ctx, args);
+    io.stdout(outputFormat === "json" ? JSON.stringify(out.json, null, 2) : out.text());
+    exitCode = out.exitCode ?? 0;
+  } catch (raw) {
+    const err = asDbError(raw) ?? raw;
+    io.stderr(formatError(err, format).text);
+    exitCode = exitCodeFor(err);
+  } finally {
+    db?.close();
+  }
+  if (exitCode !== 0)
+    io.exit(exitCode);
+}
+function dataCommand(def) {
+  return defineCommand({
+    meta: def.meta,
+    args: { ...commonArgs, ...def.args ?? {} },
+    run: ({ args }) => execute(def, args, processIo)
+  });
+}
+
+// src/commands/login.ts
+async function readHiddenToken(input, output) {
+  if (!input.isTTY || !input.setRawMode) {
+    throw new CliError("BAD_ARGS", "Interactive login requires a terminal.", "Use `oura-cli login --token` for non-interactive use.");
+  }
+  output.write("Paste your token (input hidden): ");
+  input.setRawMode(true);
+  input.resume();
+  return new Promise((resolve, reject) => {
+    let token = "";
+    const finish = () => {
+      input.off("data", onData);
+      input.setRawMode?.(false);
+      input.pause();
+      output.write(`
+`);
+    };
+    const onData = (chunk) => {
+      for (const char of chunk.toString("utf8")) {
+        if (char === "\r" || char === `
+`) {
+          finish();
+          resolve(token);
+          return;
+        }
+        if (char === "\x03" || char === "\x04") {
+          finish();
+          reject(new CliError("BAD_ARGS", "Login cancelled."));
+          return;
+        }
+        if (char === "\b" || char === "\x7F") {
+          token = token.slice(0, -1);
+        } else if (char >= " ") {
+          token += char;
+        }
+      }
+    };
+    input.on("data", onData);
+  });
+}
+function writeToken(path, token) {
+  const trimmed = token.trim();
+  if (trimmed.length === 0) {
+    throw new CliError("BAD_ARGS", "Token cannot be empty.");
+  }
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync(path, trimmed, { encoding: "utf-8" });
+  if (process.platform !== "win32") {
+    chmodSync2(path, 384);
+  }
+}
+var loginCommand = defineCommand({
+  meta: { name: "login", description: "Save an Oura Personal Access Token for future commands." },
+  args: {
+    ...commonArgs,
+    token: { type: "string", description: "Pass token non-interactively (e.g. for scripts)" },
+    path: { type: "string", description: "Where to save the token (default: $OURA_TOKEN_PATH or ~/.oura-token)" }
+  },
+  async run({ args }) {
+    try {
+      assertKnownArgs({ ...commonArgs, token: {}, path: {} }, args);
+      if (args["no-color"] || process.env.NO_COLOR) {
+        await Promise.resolve().then(() => init_source());
+        source_default.level = 0;
+      }
+      const target = args.path ?? process.env.OURA_TOKEN_PATH ?? resolve3(homedir3(), ".oura-token");
+      let token = args.token;
+      if (!token) {
+        console.log("Get a Personal Access Token at https://cloud.ouraring.com/personal-access-tokens");
+        token = await readHiddenToken(process.stdin, process.stdout);
+      }
+      writeToken(target, token);
+      console.log(source_default.green(`Saved to ${target}`));
+    } catch (err) {
+      emitError(err, "table");
+      process.exit(exitCodeFor(err));
+    }
+  }
+});
+
+// src/collections/types.ts
+function defineCollection(c) {
+  return c;
+}
+
+// src/collections/sleep.ts
+var sleep = defineCollection({
+  name: "sleep",
+  endpoint: "daily_sleep",
+  table: "daily_sleep",
+  description: "Daily sleep score and contributors",
+  conflict: "replace",
+  rangeParams: "date",
+  identity: [
+    { field: "id", description: "Oura record id" },
+    { field: "day", format: "date", description: "Date the record applies to (YYYY-MM-DD)" }
+  ],
+  columns: [
+    { name: "id", type: "TEXT", pk: true, pick: (r) => r.id },
+    { name: "day", type: "TEXT", unique: true, pick: (r) => r.day },
+    { name: "score", type: "INTEGER", pick: (r) => r.score },
+    { name: "contributors", type: "TEXT", pick: (r) => JSON.stringify(r.contributors) },
+    { name: "timestamp", type: "TEXT", pick: (r) => r.timestamp }
+  ]
+});
+
+// src/collections/readiness.ts
+var readiness = defineCollection({
+  name: "readiness",
+  endpoint: "daily_readiness",
+  table: "daily_readiness",
+  description: "Daily readiness score, contributors and temperature deviation",
+  conflict: "replace",
+  rangeParams: "date",
+  identity: [
+    { field: "id", description: "Oura record id" },
+    { field: "day", format: "date", description: "Date the record applies to (YYYY-MM-DD)" }
+  ],
+  columns: [
+    { name: "id", type: "TEXT", pk: true, pick: (r) => r.id },
+    { name: "day", type: "TEXT", unique: true, pick: (r) => r.day },
+    { name: "score", type: "INTEGER", pick: (r) => r.score },
+    { name: "contributors", type: "TEXT", pick: (r) => JSON.stringify(r.contributors) },
+    { name: "temperature_deviation", type: "REAL", pick: (r) => r.temperature_deviation },
+    { name: "temperature_trend_deviation", type: "REAL", pick: (r) => r.temperature_trend_deviation },
+    { name: "timestamp", type: "TEXT", pick: (r) => r.timestamp }
+  ]
+});
+
+// src/collections/activity.ts
+var activity = defineCollection({
+  name: "activity",
+  endpoint: "daily_activity",
+  table: "daily_activity",
+  description: "Daily activity score, steps, calories and activity-time buckets",
+  conflict: "replace",
+  rangeParams: "date",
+  identity: [
+    { field: "id", description: "Oura record id" },
+    { field: "day", format: "date", description: "Date the record applies to (YYYY-MM-DD)" }
+  ],
+  columns: [
+    { name: "id", type: "TEXT", pk: true, pick: (r) => r.id },
+    { name: "day", type: "TEXT", unique: true, pick: (r) => r.day },
+    { name: "score", type: "INTEGER", pick: (r) => r.score },
     { name: "active_calories", type: "INTEGER", pick: (r) => r.active_calories },
     { name: "steps", type: "INTEGER", pick: (r) => r.steps },
     { name: "equivalent_walking_distance", type: "REAL", pick: (r) => r.equivalent_walking_distance },
@@ -1475,6 +1954,7 @@ var workout = defineCollection({
   description: "Workout sessions with activity, calories, distance and intensity",
   conflict: "replace",
   rangeParams: "date",
+  dayRangeOffset: [0, 1],
   identity: [
     { field: "id", description: "Oura record id" },
     { field: "day", format: "date", description: "Date the record applies to (YYYY-MM-DD)" }
@@ -1501,6 +1981,7 @@ var sleepPeriods = defineCollection({
   description: "Individual sleep periods with stages, HRV, heart rate and efficiency",
   conflict: "replace",
   rangeParams: "date",
+  dayRangeOffset: [-1, 0],
   identity: [
     { field: "id", description: "Oura record id" },
     { field: "day", format: "date", description: "Date the record applies to (YYYY-MM-DD)" }
@@ -1575,13 +2056,14 @@ function rowValues(c, row) {
   return c.columns.map((col) => col.pick(row));
 }
 var MS_PER_DAY = 86400000;
-function dateQueries(start, end, maxDays) {
+function dateQueries(start, end, maxDays, offset) {
+  const query = (s, e) => ({ start_date: shiftDay(s, offset[0]), end_date: shiftDay(e, offset[1]) });
   if (!maxDays)
-    return [{ start_date: start, end_date: end }];
+    return [query(start, end)];
   const out = [];
   for (let s = start;s <= end; s = shiftDay(s, maxDays)) {
     const e = shiftDay(s, maxDays - 1);
-    out.push({ start_date: s, end_date: e < end ? e : end });
+    out.push(query(s, e < end ? e : end));
   }
   return out;
 }
@@ -1598,7 +2080,7 @@ function datetimeQueries(start, end, tz, maxDays) {
 function rangeQueries(c, start, end, tz) {
   if (start > end)
     return [];
-  return c.rangeParams === "date" ? dateQueries(start, end, c.maxRangeDays) : datetimeQueries(start, end, tz, c.maxRangeDays);
+  return c.rangeParams === "date" ? dateQueries(start, end, c.maxRangeDays, c.dayRangeOffset ?? [0, 0]) : datetimeQueries(start, end, tz, c.maxRangeDays);
 }
 async function fetchCollection(client, c, start, end, tz) {
   const rows = [];
@@ -1700,8 +2182,9 @@ function buildManifest(version, commands) {
 function describeCommand(version, getCommands) {
   return defineCommand({
     meta: { name: "describe", description: "Emit a machine-readable manifest of commands, args, and outputs." },
-    args: {},
-    run() {
+    args: { ...commonArgs },
+    run({ args }) {
+      assertKnownArgs(commonArgs, args);
       console.log(JSON.stringify(buildManifest(version, getCommands()), null, 2));
     }
   });
@@ -1709,33 +2192,41 @@ function describeCommand(version, getCommands) {
 
 // src/db/sync.ts
 var BACKFILL_DAYS = 30;
-var FRESHNESS_TABLES = ["daily_sleep", "daily_readiness", "daily_activity"];
-async function importDaily(db, client, clock, log) {
+function lastDay(db, table) {
+  return db.query(`SELECT MAX(day) AS d FROM ${table}`).get().d;
+}
+function rowCount(db, table) {
+  return db.query(`SELECT COUNT(*) AS n FROM ${table}`).get().n;
+}
+async function importDaily(db, client, clock, log, window = {}) {
   const { today, tz } = clock;
   const _log = log ?? (() => {});
-  const lastDates = [];
-  for (const tbl of FRESHNESS_TABLES) {
-    const row = db.query(`SELECT MAX(day) as d FROM ${tbl}`).get();
-    if (row?.d)
-      lastDates.push(row.d);
-  }
-  const isFirstSync = lastDates.length === 0;
-  const startDate = isFirstSync ? shiftDay(today, -BACKFILL_DAYS) : lastDates.sort()[0];
-  _log(isFirstSync ? `First sync \u2014 backfilling the last ${BACKFILL_DAYS} days: ${startDate} \u2192 ${today}` : `Syncing ${startDate} \u2192 ${today}`);
-  const counts = {};
-  for (const c of COLLECTIONS) {
-    const rows = await fetchCollection(client, c, startDate, today, tz);
+  const end = window.to ?? today;
+  const backfillStart = shiftDay(end, -(BACKFILL_DAYS - 1));
+  const plan = COLLECTIONS.map((c) => {
+    const last = lastDay(db, c.table);
+    return { c, last, start: window.from ?? last ?? backfillStart };
+  });
+  const isFirstSync = plan.every((p) => p.last === null);
+  const startDate = plan.map((p) => p.start).sort()[0];
+  _log(isFirstSync && window.from === undefined ? `First sync \u2014 backfilling the last ${BACKFILL_DAYS} days: ${startDate} \u2192 ${end}` : `Syncing ${startDate} \u2192 ${end}`);
+  const fetched = {};
+  const added = {};
+  for (const { c, start } of plan) {
+    const rows = await fetchCollection(client, c, start, end, tz);
+    const before = rowCount(db, c.table);
     const stmt = db.query(insertSql(c));
     db.transaction((rs) => {
       for (const r of rs)
         stmt.run(...rowValues(c, r));
     })(rows);
-    counts[c.table] = rows.length;
+    fetched[c.table] = rows.length;
+    added[c.table] = rowCount(db, c.table) - before;
     if (rows.length > 0)
-      _log(`  + ${c.table}: ${rows.length} rows`);
+      _log(`  + ${c.table}: ${rows.length} fetched, ${added[c.table]} new`);
   }
   _log("Import complete.");
-  return { startDate, endDate: today, counts, isFirstSync };
+  return { startDate, endDate: end, fetched, added, isFirstSync };
 }
 
 // src/db/queries.ts
@@ -1780,498 +2271,170 @@ function getTrends(db, days, today) {
     }
   }
   const sp = db.query("SELECT AVG(spo2_average) as avg, MIN(spo2_average) as min, MAX(spo2_average) as max, COUNT(*) as count FROM daily_spo2 WHERE day BETWEEN ? AND ?").get(start, today);
-  if (sp.count > 0 && sp.avg !== null) {
-    results.push({ label: "SpO2", avg: +sp.avg.toFixed(1), min: +sp.min.toFixed(1), max: +sp.max.toFixed(1), count: sp.count });
-  }
-  return results;
-}
-function getStats(db, today) {
-  const tables = COLLECTIONS.map((c) => {
-    const row = db.query(`SELECT COUNT(*) as cnt FROM ${c.table}`).get();
-    return { table: c.table, rows: row.cnt };
-  });
-  const range = db.query("SELECT MIN(day) as first, MAX(day) as last FROM daily_sleep").get();
-  const trends = getTrends(db, 99999, today);
-  const mostSteps = db.query("SELECT day, steps FROM daily_activity WHERE steps IS NOT NULL ORDER BY steps DESC LIMIT 1").get();
-  const bestSleep = db.query("SELECT day, score FROM daily_sleep WHERE score IS NOT NULL ORDER BY score DESC LIMIT 1").get();
-  return {
-    tables,
-    dateRange: range,
-    trends,
-    records: {
-      mostSteps: mostSteps ?? null,
-      bestSleep: bestSleep ?? null
-    }
-  };
-}
-
-// src/render/format.ts
-init_source();
-function scoreColor(score) {
-  if (score === null)
-    return source_default.gray("\u2014");
-  if (score >= 85)
-    return source_default.green(String(score));
-  if (score >= 70)
-    return source_default.yellow(String(score));
-  return source_default.red(String(score));
-}
-function fmtHours(h) {
-  if (h === null)
-    return source_default.gray("\u2014");
-  return `${h}h`;
-}
-function isEmptyDay(s) {
-  return s.sleep_score === null && s.readiness_score === null && s.activity_score === null && s.steps === null && s.stress === null && s.spo2 === null && s.temp_deviation === null && s.sleep_hours === null && s.deep_hours === null && s.rem_hours === null && s.avg_hrv === null && s.lowest_hr === null && s.efficiency === null;
-}
-function formatDaySummary(summary, format, emptyHint) {
-  if (format === "json")
-    return JSON.stringify(summary, null, 2);
-  if (emptyHint && isEmptyDay(summary)) {
-    return [
-      "",
-      source_default.bold(`  ${summary.day}`),
-      source_default.gray("\u2500".repeat(50)),
-      `  No Oura data for ${summary.day} yet.`,
-      `  ${emptyHint}`
-    ].join(`
-`);
-  }
-  const lines = [
-    "",
-    source_default.bold(`  ${summary.day}`),
-    source_default.gray("\u2500".repeat(50)),
-    `  Sleep:     ${scoreColor(summary.sleep_score)}    Readiness: ${scoreColor(summary.readiness_score)}    Activity: ${scoreColor(summary.activity_score)}`,
-    `  Steps:     ${summary.steps ?? source_default.gray("\u2014")}`
-  ];
-  if (summary.spo2 !== null)
-    lines.push(`  SpO2:      ${summary.spo2}%`);
-  if (summary.temp_deviation !== null) {
-    const sign = summary.temp_deviation >= 0 ? "+" : "";
-    lines.push(`  Temp:      ${sign}${summary.temp_deviation}\xB0C`);
-  }
-  if (summary.stress)
-    lines.push(`  Stress:    ${summary.stress}`);
-  if (summary.sleep_hours !== null) {
-    lines.push("");
-    lines.push(`  Sleep:     ${fmtHours(summary.sleep_hours)} total | ${fmtHours(summary.deep_hours)} deep | ${fmtHours(summary.rem_hours)} REM`);
-    lines.push(`  HRV:       ${summary.avg_hrv ?? "\u2014"}    Lowest HR: ${summary.lowest_hr ?? "\u2014"}    Efficiency: ${summary.efficiency ?? "\u2014"}%`);
-  }
-  return lines.join(`
-`);
-}
-function formatImportSummary(result) {
-  const c = result.counts;
-  return [
-    `  Imported ${result.startDate} \u2192 ${result.endDate}:`,
-    `    sleep ${c.daily_sleep ?? 0}   readiness ${c.daily_readiness ?? 0}   activity ${c.daily_activity ?? 0}   sleep periods ${c.sleep_model ?? 0}`,
-    `    spo2 ${c.daily_spo2 ?? 0}    stress ${c.daily_stress ?? 0}      workouts ${c.workouts ?? 0}   heart rate ${c.heartrate ?? 0}   cardiovascular age ${c.cardiovascular_age ?? 0}`
-  ].join(`
-`);
-}
-function formatWeekTable(days, format, emptyHint) {
-  if (format === "json")
-    return JSON.stringify(days, null, 2);
-  if (emptyHint && days.length > 0 && days.every(isEmptyDay)) {
-    return [
-      "",
-      "  No Oura data for the last 7 days yet.",
-      `  ${emptyHint}`
-    ].join(`
-`);
-  }
-  const header = `${"Day".padEnd(12)} ${"Sleep".padStart(6)} ${"Ready".padStart(6)} ${"Activity".padStart(9)} ${"Steps".padStart(7)} ${"Stress".padEnd(10)}`;
-  const sep = source_default.gray("\u2500".repeat(56));
-  const rows = days.map((d) => `${d.day.padEnd(12)} ${scoreColor(d.sleep_score).padStart(6)} ${scoreColor(d.readiness_score).padStart(6)} ` + `${scoreColor(d.activity_score).padStart(9)} ${String(d.steps ?? "\u2014").padStart(7)} ${(d.stress ?? "\u2014").padEnd(10)}`);
-  return [`
-  Last 7 Days`, sep, `  ${header}`, sep, ...rows.map((r) => `  ${r}`)].join(`
-`);
-}
-function formatTrends(trends, days, format) {
-  if (format === "json")
-    return JSON.stringify(trends, null, 2);
-  const lines = [
-    "",
-    source_default.bold(`  Trends: last ${days} days`),
-    source_default.gray("\u2500".repeat(50))
-  ];
-  for (const t of trends) {
-    lines.push(`  ${t.label.padEnd(15)} avg: ${String(t.avg).padStart(5)}  min: ${String(t.min).padStart(5)}  max: ${String(t.max).padStart(5)}  (${t.count} days)`);
-  }
-  return lines.join(`
-`);
-}
-function formatStats(stats, format) {
-  if (format === "json")
-    return JSON.stringify(stats, null, 2);
-  const lines = [
-    "",
-    source_default.bold("  Database Statistics"),
-    source_default.gray("\u2550".repeat(50))
-  ];
-  for (const t of stats.tables) {
-    lines.push(`  ${t.table.padEnd(22)} ${String(t.rows).padStart(8)} rows`);
-  }
-  if (stats.dateRange.first) {
-    lines.push(`
-  Date range: ${stats.dateRange.first} \u2192 ${stats.dateRange.last}`);
-  }
-  for (const t of stats.trends) {
-    lines.push(`  ${t.label.padEnd(15)} avg: ${String(t.avg).padStart(5)}  min: ${String(t.min).padStart(5)}  max: ${String(t.max).padStart(5)}`);
-  }
-  if (stats.records.mostSteps) {
-    lines.push(`
-  Most steps:  ${stats.records.mostSteps.steps} on ${stats.records.mostSteps.day}`);
-  }
-  if (stats.records.bestSleep) {
-    lines.push(`  Best sleep:  ${stats.records.bestSleep.score} on ${stats.records.bestSleep.day}`);
-  }
-  return lines.join(`
-`);
-}
-
-// src/commands/run-command.ts
-init_source();
-
-// src/db/open.ts
-import { Database } from "bun:sqlite";
-import { resolve as resolve2, dirname as dirname2 } from "path";
-import { homedir as homedir2 } from "os";
-import { mkdirSync as mkdirSync2 } from "fs";
-
-// src/db/migrations.ts
-var MIGRATIONS = [
-  {
-    version: 1,
-    sql: `
-CREATE TABLE IF NOT EXISTS daily_sleep (
-    id TEXT PRIMARY KEY,
-    day TEXT UNIQUE,
-    score INTEGER,
-    contributors TEXT,
-    timestamp TEXT
-);
-CREATE TABLE IF NOT EXISTS daily_readiness (
-    id TEXT PRIMARY KEY,
-    day TEXT UNIQUE,
-    score INTEGER,
-    contributors TEXT,
-    temperature_deviation REAL,
-    temperature_trend_deviation REAL,
-    timestamp TEXT
-);
-CREATE TABLE IF NOT EXISTS daily_activity (
-    id TEXT PRIMARY KEY,
-    day TEXT UNIQUE,
-    score INTEGER,
-    active_calories INTEGER,
-    steps INTEGER,
-    equivalent_walking_distance REAL,
-    high_activity_time INTEGER,
-    medium_activity_time INTEGER,
-    low_activity_time INTEGER,
-    sedentary_time INTEGER,
-    total_calories INTEGER,
-    target_calories INTEGER,
-    contributors TEXT,
-    timestamp TEXT
-);
-CREATE TABLE IF NOT EXISTS daily_spo2 (
-    id TEXT PRIMARY KEY,
-    day TEXT UNIQUE,
-    spo2_average REAL,
-    breathing_disturbance_index REAL
-);
-CREATE TABLE IF NOT EXISTS daily_stress (
-    id TEXT PRIMARY KEY,
-    day TEXT UNIQUE,
-    day_summary TEXT,
-    recovery_high INTEGER,
-    stress_high INTEGER
-);
-CREATE TABLE IF NOT EXISTS heartrate (
-    timestamp TEXT,
-    bpm INTEGER,
-    source TEXT,
-    day TEXT
-);
-CREATE INDEX IF NOT EXISTS idx_heartrate_ts ON heartrate(timestamp);
-CREATE UNIQUE INDEX IF NOT EXISTS idx_heartrate_unique ON heartrate(timestamp, source);
-CREATE INDEX IF NOT EXISTS idx_heartrate_day ON heartrate(day);
-CREATE TABLE IF NOT EXISTS vo2max (
-    id TEXT PRIMARY KEY,
-    day TEXT UNIQUE,
-    vo2_max REAL,
-    timestamp TEXT
-);
-CREATE TABLE IF NOT EXISTS cardiovascular_age (
-    id TEXT PRIMARY KEY,
-    day TEXT UNIQUE,
-    vascular_age INTEGER
-);
-CREATE TABLE IF NOT EXISTS workouts (
-    id TEXT PRIMARY KEY,
-    day TEXT,
-    activity TEXT,
-    calories REAL,
-    distance REAL,
-    start_datetime TEXT,
-    end_datetime TEXT,
-    intensity TEXT,
-    label TEXT,
-    source TEXT
-);
-CREATE TABLE IF NOT EXISTS sleep_model (
-    id TEXT PRIMARY KEY,
-    day TEXT,
-    average_breath REAL,
-    average_heart_rate REAL,
-    average_hrv REAL,
-    awake_time INTEGER,
-    bedtime_end TEXT,
-    bedtime_start TEXT,
-    deep_sleep_duration INTEGER,
-    efficiency INTEGER,
-    latency INTEGER,
-    light_sleep_duration INTEGER,
-    lowest_heart_rate INTEGER,
-    period INTEGER,
-    rem_sleep_duration INTEGER,
-    restless_periods INTEGER,
-    time_in_bed INTEGER,
-    total_sleep_duration INTEGER,
-    type TEXT
-);
-    `
-  },
-  {
-    version: 2,
-    sql: `
-CREATE VIEW IF NOT EXISTS v_weekly_sleep AS
-    SELECT strftime('%Y-W%W', day) as week, ROUND(AVG(score),1) as avg_score, COUNT(*) as days
-    FROM daily_sleep WHERE score IS NOT NULL GROUP BY week ORDER BY week DESC;
-
-CREATE VIEW IF NOT EXISTS v_weekly_readiness AS
-    SELECT strftime('%Y-W%W', day) as week, ROUND(AVG(score),1) as avg_score,
-        ROUND(AVG(temperature_deviation),2) as avg_temp_dev, COUNT(*) as days
-    FROM daily_readiness WHERE score IS NOT NULL GROUP BY week ORDER BY week DESC;
-
-CREATE VIEW IF NOT EXISTS v_weekly_activity AS
-    SELECT strftime('%Y-W%W', day) as week, ROUND(AVG(score),1) as avg_score,
-        SUM(steps) as total_steps, SUM(active_calories) as total_active_cal, COUNT(*) as days
-    FROM daily_activity WHERE score IS NOT NULL GROUP BY week ORDER BY week DESC;
-
-CREATE VIEW IF NOT EXISTS v_sleep_detail AS
-    SELECT day, ROUND(total_sleep_duration/3600.0,1) as sleep_hours,
-        ROUND(deep_sleep_duration/3600.0,1) as deep_hours,
-        ROUND(rem_sleep_duration/3600.0,1) as rem_hours,
-        average_hrv, average_heart_rate as avg_hr, lowest_heart_rate as lowest_hr, efficiency
-    FROM sleep_model ORDER BY day DESC;
-    `
-  }
-];
-
-// src/db/open.ts
-function getDbPath(explicit) {
-  if (explicit)
-    return explicit;
-  if (process.env.OURA_DB_PATH)
-    return process.env.OURA_DB_PATH;
-  return resolve2(homedir2(), ".oura-cli", "oura.db");
-}
-function openDatabase(explicit) {
-  const dbPath = getDbPath(explicit);
-  if (dbPath !== ":memory:")
-    mkdirSync2(dirname2(dbPath), { recursive: true });
-  const db = new Database(dbPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  return db;
-}
-function schemaVersion(db) {
-  db.exec("CREATE TABLE IF NOT EXISTS _schema_version (version INTEGER NOT NULL)");
-  const row = db.query("SELECT MAX(version) AS v FROM _schema_version").get();
-  return row?.v ?? 0;
-}
-function ensureSchema(db, migrations = MIGRATIONS) {
-  const current = schemaVersion(db);
-  for (const m of migrations) {
-    if (m.version > current) {
-      db.exec(m.sql);
-      db.query("INSERT INTO _schema_version (version) VALUES (?)").run(m.version);
-    }
-  }
-}
-
-// src/api/token.ts
-import { readFileSync } from "fs";
-import { resolve as resolve3 } from "path";
-import { homedir as homedir3 } from "os";
-function defaultTokenPath() {
-  return process.env.OURA_TOKEN_PATH ?? resolve3(homedir3(), ".oura-token");
-}
-function resolveToken(explicit, tokenPath) {
-  if (explicit)
-    return { token: explicit.trim(), source: "--token" };
-  if (process.env.OURA_TOKEN)
-    return { token: process.env.OURA_TOKEN.trim(), source: "OURA_TOKEN" };
-  const path = tokenPath ?? defaultTokenPath();
-  try {
-    return { token: readFileSync(path, "utf-8").trim(), source: path };
-  } catch {
-    return { token: null, source: path };
-  }
-}
-
-// src/api/client.ts
-var BASE_URL = "https://api.ouraring.com/v2/usercollection";
-var MAX_PAGES = 1e4;
-
-class OuraClient {
-  token;
-  constructor(options = {}) {
-    const { token, source } = resolveToken(options.token, options.tokenPath);
-    if (!token) {
-      throw new CliError("TOKEN_MISSING", `No Oura access token at ${source}.`, "Run `oura-cli login` or set OURA_TOKEN.");
-    }
-    this.token = token;
-  }
-  async fetch(endpoint, query) {
-    const rows = [];
-    const seenTokens = new Set;
-    let nextToken = null;
-    do {
-      if (seenTokens.size >= MAX_PAGES) {
-        throw new CliError("API_ERROR", `Oura API returned more than ${MAX_PAGES} pages for ${endpoint}; stopping.`);
-      }
-      const params = new URLSearchParams(query);
-      if (nextToken)
-        params.set("next_token", nextToken);
-      const page = await this.getPage(`${BASE_URL}/${endpoint}?${params}`);
-      for (const row of page.data)
-        rows.push(row);
-      nextToken = page.next_token;
-      if (nextToken && seenTokens.has(nextToken)) {
-        throw new CliError("API_ERROR", `Oura API repeated pagination token for ${endpoint}; stopping to avoid a loop.`);
-      }
-      if (nextToken)
-        seenTokens.add(nextToken);
-    } while (nextToken);
-    return rows;
-  }
-  async getPage(url) {
-    const response = await fetch(url, {
-      headers: { Authorization: `Bearer ${this.token}` }
-    });
-    if (!response.ok) {
-      const rawBody = await response.text();
-      const redacted = redactSecrets(rawBody);
-      const body = redacted.length > 200 ? redacted.slice(0, 200) + "\u2026 (truncated)" : redacted;
-      if (response.status === 401 || response.status === 403) {
-        throw new CliError("TOKEN_INVALID", `Oura API ${response.status}: ${body}`);
-      }
-      throw new CliError("API_ERROR", `Oura API ${response.status}: ${body}`);
-    }
-    let json;
-    try {
-      json = await response.json();
-    } catch {
-      throw new CliError("API_ERROR", "Empty response body from Oura API.");
-    }
-    const body = json;
-    return { data: body.data ?? [], next_token: body.next_token ?? null };
+  if (sp.count > 0 && sp.avg !== null) {
+    results.push({ label: "SpO2", avg: +sp.avg.toFixed(1), min: +sp.min.toFixed(1), max: +sp.max.toFixed(1), count: sp.count });
   }
+  return results;
 }
-
-// src/lib/format-resolve.ts
-function resolveFormat({ explicit, isTty }) {
-  if (explicit === undefined)
-    return isTty ? "table" : "json";
-  if (explicit === "table" || explicit === "json")
-    return explicit;
-  throw new CliError("BAD_ARGS", `Unknown --format value: "${explicit}". Use "table" or "json".`);
+function getStats(db, today) {
+  const tables = COLLECTIONS.map((c) => {
+    const row = db.query(`SELECT COUNT(*) as cnt FROM ${c.table}`).get();
+    return { table: c.table, rows: row.cnt };
+  });
+  const range = db.query("SELECT MIN(day) as first, MAX(day) as last FROM daily_sleep").get();
+  const trends = getTrends(db, 99999, today);
+  const mostSteps = db.query("SELECT day, steps FROM daily_activity WHERE steps IS NOT NULL ORDER BY steps DESC LIMIT 1").get();
+  const bestSleep = db.query("SELECT day, score FROM daily_sleep WHERE score IS NOT NULL ORDER BY score DESC LIMIT 1").get();
+  return {
+    tables,
+    dateRange: range,
+    trends,
+    records: {
+      mostSteps: mostSteps ?? null,
+      bestSleep: bestSleep ?? null
+    }
+  };
 }
 
-// src/lib/validate.ts
-function assertCalendarDate(value, label) {
-  if (!isCalendarDate(value)) {
-    throw new CliError("BAD_ARGS", `${label} must be a real YYYY-MM-DD date, got "${value}".`);
-  }
-  return value;
+// src/render/format.ts
+init_source();
+function scoreColor(score) {
+  if (score === null)
+    return source_default.gray("\u2014");
+  if (score >= 85)
+    return source_default.green(String(score));
+  if (score >= 70)
+    return source_default.yellow(String(score));
+  return source_default.red(String(score));
 }
-function assertPositiveInt(value, label) {
-  const n = Number(value);
-  if (!/^\d+$/.test(value.trim()) || !Number.isSafeInteger(n) || n < 1) {
-    throw new CliError("BAD_ARGS", `${label} must be a positive integer, got "${value}".`);
-  }
-  return n;
+function fmtHours(h) {
+  if (h === null)
+    return source_default.gray("\u2014");
+  return `${h}h`;
 }
-function assertTimezone(tz) {
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: tz });
-    return tz;
-  } catch {
-    throw new CliError("BAD_ARGS", `Unknown timezone "${tz}".`, "Use an IANA name such as Europe/Berlin (env: OURA_TZ, flag: --tz).");
+function isEmptyDay(s) {
+  return s.sleep_score === null && s.readiness_score === null && s.activity_score === null && s.steps === null && s.stress === null && s.spo2 === null && s.temp_deviation === null && s.sleep_hours === null && s.deep_hours === null && s.rem_hours === null && s.avg_hrv === null && s.lowest_hr === null && s.efficiency === null;
+}
+function formatDaySummary(summary, format, emptyHint) {
+  if (format === "json")
+    return JSON.stringify(summary, null, 2);
+  if (emptyHint && isEmptyDay(summary)) {
+    return [
+      "",
+      source_default.bold(`  ${summary.day}`),
+      source_default.gray("\u2500".repeat(50)),
+      `  No Oura data for ${summary.day} yet.`,
+      `  ${emptyHint}`
+    ].join(`
+`);
+  }
+  const lines = [
+    "",
+    source_default.bold(`  ${summary.day}`),
+    source_default.gray("\u2500".repeat(50)),
+    `  Sleep:     ${scoreColor(summary.sleep_score)}    Readiness: ${scoreColor(summary.readiness_score)}    Activity: ${scoreColor(summary.activity_score)}`,
+    `  Steps:     ${summary.steps ?? source_default.gray("\u2014")}`
+  ];
+  if (summary.spo2 !== null)
+    lines.push(`  SpO2:      ${summary.spo2}%`);
+  if (summary.temp_deviation !== null) {
+    const sign = summary.temp_deviation >= 0 ? "+" : "";
+    lines.push(`  Temp:      ${sign}${summary.temp_deviation}\xB0C`);
+  }
+  if (summary.stress)
+    lines.push(`  Stress:    ${summary.stress}`);
+  if (summary.sleep_hours !== null) {
+    lines.push("");
+    lines.push(`  Sleep:     ${fmtHours(summary.sleep_hours)} total | ${fmtHours(summary.deep_hours)} deep | ${fmtHours(summary.rem_hours)} REM`);
+    lines.push(`  HRV:       ${summary.avg_hrv ?? "\u2014"}    Lowest HR: ${summary.lowest_hr ?? "\u2014"}    Efficiency: ${summary.efficiency ?? "\u2014"}%`);
   }
+  return lines.join(`
+`);
 }
-
-// src/commands/run-command.ts
-var processIo = {
-  stdout: (s) => {
-    process.stdout.write(s + `
+function formatImportSummary(result) {
+  const n = (table) => `${result.fetched[table] ?? 0} (+${result.added[table] ?? 0})`;
+  return [
+    `  Fetched ${result.startDate} \u2192 ${result.endDate}, rows fetched (+new):`,
+    `    sleep ${n("daily_sleep")}   readiness ${n("daily_readiness")}   activity ${n("daily_activity")}   sleep periods ${n("sleep_model")}`,
+    `    spo2 ${n("daily_spo2")}   stress ${n("daily_stress")}   workouts ${n("workouts")}   heart rate ${n("heartrate")}   cardiovascular age ${n("cardiovascular_age")}`
+  ].join(`
 `);
-  },
-  stderr: (s) => {
-    process.stderr.write(s + `
+}
+function formatWeekTable(days, format, emptyHint) {
+  if (format === "json")
+    return JSON.stringify(days, null, 2);
+  if (emptyHint && days.length > 0 && days.every(isEmptyDay)) {
+    return [
+      "",
+      "  No Oura data for the last 7 days yet.",
+      `  ${emptyHint}`
+    ].join(`
 `);
-  },
-  exit: (code) => process.exit(code),
-  isTty: process.stdout.isTTY === true
-};
-async function execute(def, args, io = processIo) {
-  if (args["no-color"] || process.env.NO_COLOR)
-    source_default.level = 0;
-  let db;
-  let format = io.isTty ? "table" : "json";
-  let exitCode = 0;
-  try {
-    format = resolveFormat({ explicit: args.format, isTty: io.isTty });
-    const outputFormat = def.jsonOnly ? "json" : format;
-    const tz = assertTimezone(args.tz ?? resolveDefaultTimezone());
-    const ctx = { format: outputFormat, tz, today: today(tz) };
-    if (def.needs?.db) {
-      db = openDatabase(args.db);
-      ensureSchema(db);
-      ctx.db = db;
-    }
-    if (def.needs?.client) {
-      ctx.client = new OuraClient(args.token ? { token: args.token } : {});
-    }
-    const out = await def.run(ctx, args);
-    io.stdout(outputFormat === "json" ? JSON.stringify(out.json, null, 2) : out.text());
-    exitCode = out.exitCode ?? 0;
-  } catch (err) {
-    io.stderr(formatError(err, format).text);
-    exitCode = exitCodeFor(err);
-  } finally {
-    db?.close();
   }
-  if (exitCode !== 0)
-    io.exit(exitCode);
+  const header = `${"Day".padEnd(12)} ${"Sleep".padStart(6)} ${"Ready".padStart(6)} ${"Activity".padStart(9)} ${"Steps".padStart(7)} ${"Stress".padEnd(10)}`;
+  const sep = source_default.gray("\u2500".repeat(56));
+  const rows = days.map((d) => `${d.day.padEnd(12)} ${scoreColor(d.sleep_score).padStart(6)} ${scoreColor(d.readiness_score).padStart(6)} ` + `${scoreColor(d.activity_score).padStart(9)} ${String(d.steps ?? "\u2014").padStart(7)} ${(d.stress ?? "\u2014").padEnd(10)}`);
+  return [`
+  Last 7 Days`, sep, `  ${header}`, sep, ...rows.map((r) => `  ${r}`)].join(`
+`);
 }
-function dataCommand(def) {
-  return defineCommand({
-    meta: def.meta,
-    args: { ...commonArgs, ...def.args ?? {} },
-    run: ({ args }) => execute(def, args, processIo)
-  });
+function formatTrends(trends, days, format) {
+  if (format === "json")
+    return JSON.stringify(trends, null, 2);
+  const lines = [
+    "",
+    source_default.bold(`  Trends: last ${days} days`),
+    source_default.gray("\u2500".repeat(50))
+  ];
+  for (const t of trends) {
+    lines.push(`  ${t.label.padEnd(15)} avg: ${String(t.avg).padStart(5)}  min: ${String(t.min).padStart(5)}  max: ${String(t.max).padStart(5)}  (${t.count} days)`);
+  }
+  return lines.join(`
+`);
+}
+function formatStats(stats, format) {
+  if (format === "json")
+    return JSON.stringify(stats, null, 2);
+  const lines = [
+    "",
+    source_default.bold("  Database Statistics"),
+    source_default.gray("\u2550".repeat(50))
+  ];
+  for (const t of stats.tables) {
+    lines.push(`  ${t.table.padEnd(22)} ${String(t.rows).padStart(8)} rows`);
+  }
+  if (stats.dateRange.first) {
+    lines.push(`
+  Date range: ${stats.dateRange.first} \u2192 ${stats.dateRange.last}`);
+  }
+  for (const t of stats.trends) {
+    lines.push(`  ${t.label.padEnd(15)} avg: ${String(t.avg).padStart(5)}  min: ${String(t.min).padStart(5)}  max: ${String(t.max).padStart(5)}`);
+  }
+  if (stats.records.mostSteps) {
+    lines.push(`
+  Most steps:  ${stats.records.mostSteps.steps} on ${stats.records.mostSteps.day}`);
+  }
+  if (stats.records.bestSleep) {
+    lines.push(`  Best sleep:  ${stats.records.bestSleep.score} on ${stats.records.bestSleep.day}`);
+  }
+  return lines.join(`
+`);
 }
 
 // src/commands/sync.ts
-async function runSync(ctx) {
+function resolveWindow(opts) {
+  if (opts.to !== undefined && opts.from === undefined)
+    throw new CliError("BAD_ARGS", "--to requires --from.");
+  const from = opts.from === undefined ? undefined : assertCalendarDate(opts.from, "--from");
+  const to = opts.to === undefined ? undefined : assertCalendarDate(opts.to, "--to");
+  if (from !== undefined && to !== undefined && from > to)
+    throw new CliError("BAD_ARGS", `--from (${from}) must not be after --to (${to}).`);
+  return { from, to };
+}
+async function runSync(ctx, window = {}) {
   const lines = [];
   const log = ctx.format === "table" ? (m) => lines.push(m) : undefined;
-  const importResult = await importDaily(ctx.db, ctx.client, { today: ctx.today, tz: ctx.tz }, log);
+  const importResult = await importDaily(ctx.db, ctx.client, { today: ctx.today, tz: ctx.tz }, log, window);
   const today = getDaySummary(ctx.db, ctx.today);
   return {
     json: { import: importResult, today },
@@ -2281,8 +2444,12 @@ async function runSync(ctx) {
 }
 var syncCommand = dataCommand({
   meta: { name: "sync", description: "Import latest data from Oura API and return today's summary" },
+  args: {
+    from: { type: "string", description: "Re-fetch every collection from this day (YYYY-MM-DD) instead of from its last stored day" },
+    to: { type: "string", description: "End of the explicit window (YYYY-MM-DD, default: today); requires --from" }
+  },
   needs: { db: true, client: true },
-  run: runSync
+  run: (ctx, args) => runSync(ctx, resolveWindow({ from: args.from, to: args.to }))
 });
 
 // src/commands/db.ts
@@ -2591,6 +2758,7 @@ function healthcheckCommand(version) {
     meta: { name: "healthcheck", description: "Quick local DB health probe (JSON: {ok, version, latencyMs})." },
     args: { ...commonArgs },
     run({ args }) {
+      assertKnownArgs(commonArgs, args);
       const start = Date.now();
       let ok = true;
       let error;
@@ -2615,6 +2783,8 @@ function statusSymbol(status) {
     return source_default.green("\u2713");
   if (status === "warn")
     return source_default.yellow("!");
+  if (status === "skip")
+    return source_default.gray("\u2013");
   return source_default.red("\u2717");
 }
 function formatDoctorTable(result) {
@@ -2641,7 +2811,7 @@ async function runChecks(deps) {
   if (!token) {
     checks.push({ id: "token-valid", status: "fail", detail: "No token to validate.", fix: "oura-cli login" });
   } else if (deps.offline) {
-    checks.push({ id: "token-valid", status: "ok", detail: "Skipped (--offline)." });
+    checks.push({ id: "token-valid", status: "skip", detail: "Not checked (--offline)." });
   } else {
     try {
       const client = deps.createClient(token);
@@ -2681,8 +2851,9 @@ async function runChecks(deps) {
     checks.push({ id: "data", status: "fail", detail: "Cannot check data \u2014 database unavailable." });
   }
   db?.close();
-  const ok = checks.every((c) => c.status === "ok");
-  const nextStep = checks.find((c) => c.status !== "ok")?.fix ?? null;
+  const settled = (s) => s === "ok" || s === "skip";
+  const ok = checks.every((c) => settled(c.status));
+  const nextStep = checks.find((c) => !settled(c.status))?.fix ?? null;
   return { ok, checks, nextStep };
 }
 var DATA_TABLES = ["daily_sleep", "daily_readiness", "daily_activity"];
@@ -2754,8 +2925,9 @@ function buildOpenclawManifest(version, commands) {
 function manifestCommand(version, getCommands) {
   return defineCommand({
     meta: { name: "manifest", description: "Print openclaw-tool-registry-compatible manifest as JSON." },
-    args: {},
-    run() {
+    args: { ...commonArgs },
+    run({ args }) {
+      assertKnownArgs(commonArgs, args);
       console.log(JSON.stringify(buildOpenclawManifest(version, getCommands()), null, 2));
     }
   });
@@ -2812,53 +2984,26 @@ var fetchCommand = dataCommand({
   }
 });
 
-// src/lib/argv-normalize.ts
-var GLOBAL_FLAGS_WITH_VALUE = new Set(["--format", "--token", "--db", "--tz"]);
-var GLOBAL_FLAGS_BOOLEAN = new Set(["--no-color"]);
-var SUBCOMMANDS = new Set([
-  "login",
-  "describe",
-  "healthcheck",
-  "doctor",
-  "manifest",
-  "fetch",
-  "sync",
-  "db",
-  "report"
-]);
-function normalizeArgv(argv) {
-  const [bun, script, ...rest] = argv;
-  const subIdx = rest.findIndex((a) => SUBCOMMANDS.has(a));
-  if (subIdx < 0)
-    return argv;
-  const before = rest.slice(0, subIdx);
-  const subcommandOnwards = rest.slice(subIdx);
-  const hoisted = [];
-  const leftover = [];
-  for (let i = 0;i < before.length; i++) {
-    const tok = before[i];
-    if (tok.includes("=")) {
-      const name = tok.slice(0, tok.indexOf("="));
-      if (GLOBAL_FLAGS_WITH_VALUE.has(name) || GLOBAL_FLAGS_BOOLEAN.has(name)) {
-        hoisted.push(tok);
-        continue;
-      }
-    }
-    if (GLOBAL_FLAGS_WITH_VALUE.has(tok)) {
-      hoisted.push(tok);
-      if (i + 1 < before.length) {
-        hoisted.push(before[i + 1]);
-        i++;
-      }
-      continue;
-    }
-    if (GLOBAL_FLAGS_BOOLEAN.has(tok)) {
-      hoisted.push(tok);
-      continue;
+// src/lib/citty-error.ts
+var ANSI = /\u001b\[[0-9;]*m/g;
+function fromCittyError(err, removedCommandHints = {}) {
+  const code = err?.code;
+  if (typeof code !== "string")
+    return err;
+  const message = (err instanceof Error ? err.message : String(err)).replace(ANSI, "");
+  switch (code) {
+    case "E_UNKNOWN_COMMAND": {
+      const name = message.replace(/^Unknown command\s*/, "").trim();
+      const hint = Object.hasOwn(removedCommandHints, name) ? removedCommandHints[name] : "Run `oura-cli --help` for the list of commands.";
+      return new CliError("BAD_ARGS", `Unknown command "${name}".`, hint);
     }
-    leftover.push(tok);
+    case "EARG":
+      return new CliError("BAD_ARGS", message.endsWith(".") ? message : `${message}.`, "Run the command with --help to see its arguments.");
+    case "E_NO_COMMAND":
+      return new CliError("BAD_ARGS", "No command specified.", "Run `oura-cli --help` for the list of commands.");
+    default:
+      return err;
   }
-  return [bun, script, ...leftover, ...subcommandOnwards, ...hoisted];
 }
 
 // src/index.ts
@@ -2866,7 +3011,7 @@ var VERSION = JSON.parse(readFileSync2(new URL("../package.json", import.meta.ur
 if (process.argv.includes("--no-color") || process.env.NO_COLOR) {
   source_default.level = 0;
 }
-var subCommands = {
+var subCommands = Object.assign(Object.create(null), {
   login: loginCommand,
   describe: describeCommand(VERSION, () => subCommands),
   healthcheck: healthcheckCommand(VERSION),
@@ -2876,6 +3021,18 @@ var subCommands = {
   sync: syncCommand,
   db: dbCommand,
   report: reportCommand
+});
+var FETCH_HINT = "The per-collection commands were replaced in 0.5.0 by `oura-cli fetch <collection>`, e.g. `oura-cli fetch sleep --day 2026-09-01`. Run `oura-cli fetch --help`.";
+var REMOVED_COMMANDS = {
+  reset: "`db reset` was removed in 0.5.0; delete the database file (`--db` / OURA_DB_PATH) and run `oura-cli sync` to rebuild it.",
+  import: "`db import` was removed in 0.5.0; `oura-cli sync` downloads and stores everything.",
+  sleep: FETCH_HINT,
+  readiness: FETCH_HINT,
+  activity: FETCH_HINT,
+  hr: FETCH_HINT,
+  spo2: FETCH_HINT,
+  stress: FETCH_HINT,
+  workout: FETCH_HINT
 };
 var main = defineCommand({
   meta: {
@@ -2886,5 +3043,16 @@ var main = defineCommand({
   args: { ...commonArgs },
   subCommands
 });
-var normalized = normalizeArgv(process.argv);
-runMain(main, { rawArgs: normalized.slice(2) });
+var rawArgs = normalizeArgv(process.argv).slice(2);
+var wantsHelp = rawArgs.some((a) => a === "--help" || a === "-h") || rawArgs.length === 0 && process.stdout.isTTY === true;
+if (isVersionRequest(rawArgs)) {
+  console.log(VERSION);
+} else if (wantsHelp) {
+  runMain(main, { rawArgs });
+} else {
+  runCommand(main, { rawArgs }).catch((raw) => {
+    const err = fromCittyError(raw, REMOVED_COMMANDS);
+    emitError(err, formatFromArgv(rawArgs, process.stdout.isTTY === true));
+    process.exit(exitCodeFor(err));
+  });
+}