@drakulavich/oura-cli 0.4.5 → 0.5.0

package/dist/index.js

@@ -1,20 +1,49 @@
 #!/usr/bin/env bun
 // @bun
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, postfix) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + postfix;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const isGotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, isGotCR ? index - 1 : index) + prefix + (isGotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 function assembleStyles() {
@@ -26,7 +55,7 @@ function assembleStyles() {
         close: `\x1B[${style[1]}m`
       };
       group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
+      codes.set(Number.parseInt(style[0], 10), style[1]);
     }
     Object.defineProperty(styles, groupName, {
       value: group,
@@ -39,12 +68,16 @@ function assembleStyles() {
   });
   styles.color.close = "\x1B[39m";
   styles.bgColor.close = "\x1B[49m";
+  styles.underlineColor.close = "\x1B[59m";
   styles.color.ansi = wrapAnsi16();
   styles.color.ansi256 = wrapAnsi256();
   styles.color.ansi16m = wrapAnsi16m();
   styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
   styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
   styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  styles.underlineColor.ansi = wrapUnderlineAnsi;
+  styles.underlineColor.ansi256 = wrapAnsi256(ANSI_UNDERLINE_OFFSET);
+  styles.underlineColor.ansi16m = wrapAnsi16m(ANSI_UNDERLINE_OFFSET);
   Object.defineProperties(styles, {
     rgbToAnsi256: {
       value(red, green, blue) {
@@ -63,7 +96,7 @@ function assembleStyles() {
     },
     hexToRgb: {
       value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        const matches = /[\da-f]{6}|[\da-f]{3}/i.exec(hex.toString(16));
         if (!matches) {
           return [0, 0, 0];
         }
@@ -129,7 +162,7 @@ function assembleStyles() {
   });
   return styles;
 }
-var ANSI_BACKGROUND_OFFSET = 10, wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`, wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var ANSI_BACKGROUND_OFFSET = 10, ANSI_UNDERLINE_OFFSET = 20, wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`, wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`, wrapUnderlineAnsi = (code) => `\x1B[58;5;${code < 90 ? code - 30 : code - 90 + 8}m`, styles, modifierNames, foregroundColorNames, backgroundColorNames, underlineColorNames, colorNames, ansiStyles, ansi_styles_default;
 var init_ansi_styles = __esm(() => {
   styles = {
     modifier: {
@@ -138,6 +171,10 @@ var init_ansi_styles = __esm(() => {
       dim: [2, 22],
       italic: [3, 23],
       underline: [4, 24],
+      underlineDouble: ["4:2", 24],
+      underlineCurly: ["4:3", 24],
+      underlineDotted: ["4:4", 24],
+      underlineDashed: ["4:5", 24],
       overline: [53, 55],
       inverse: [7, 27],
       hidden: [8, 28],
@@ -182,11 +219,32 @@ var init_ansi_styles = __esm(() => {
       bgMagentaBright: [105, 49],
       bgCyanBright: [106, 49],
       bgWhiteBright: [107, 49]
+    },
+    underlineColor: {
+      underlineBlack: ["58;5;0", 59],
+      underlineRed: ["58;5;1", 59],
+      underlineGreen: ["58;5;2", 59],
+      underlineYellow: ["58;5;3", 59],
+      underlineBlue: ["58;5;4", 59],
+      underlineMagenta: ["58;5;5", 59],
+      underlineCyan: ["58;5;6", 59],
+      underlineWhite: ["58;5;7", 59],
+      underlineBlackBright: ["58;5;8", 59],
+      underlineGray: ["58;5;8", 59],
+      underlineGrey: ["58;5;8", 59],
+      underlineRedBright: ["58;5;9", 59],
+      underlineGreenBright: ["58;5;10", 59],
+      underlineYellowBright: ["58;5;11", 59],
+      underlineBlueBright: ["58;5;12", 59],
+      underlineMagentaBright: ["58;5;13", 59],
+      underlineCyanBright: ["58;5;14", 59],
+      underlineWhiteBright: ["58;5;15", 59]
     }
   };
   modifierNames = Object.keys(styles.modifier);
   foregroundColorNames = Object.keys(styles.color);
   backgroundColorNames = Object.keys(styles.bgColor);
+  underlineColorNames = Object.keys(styles.underlineColor);
   colorNames = [...foregroundColorNames, ...backgroundColorNames];
   ansiStyles = assembleStyles();
   ansi_styles_default = ansiStyles;
@@ -202,16 +260,23 @@ function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.
   const terminatorPosition = argv.indexOf("--");
   return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 }
+function hasNumericForceColor() {
+  return /^\d+$/.test(env.FORCE_COLOR);
+}
 function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  if (!("FORCE_COLOR" in env)) {
+    return;
+  }
+  if (env.FORCE_COLOR === "false") {
+    return 0;
+  }
+  if (env.FORCE_COLOR === "true" || env.FORCE_COLOR.length === 0) {
+    return 1;
+  }
+  if (!hasNumericForceColor()) {
+    return;
   }
+  return Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
 }
 function translateLevel(level) {
   if (level === 0) {
@@ -241,6 +306,9 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
       return 2;
     }
   }
+  if (forceColor !== undefined && hasNumericForceColor()) {
+    return forceColor;
+  }
   if ("TF_BUILD" in env && "AGENT_NAME" in env) {
     return 1;
   }
@@ -268,7 +336,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return min;
   }
   if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    return /^(?:9\.0*[1-9]\d*\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
   }
   if (env.COLORTERM === "truecolor") {
     return 3;
@@ -283,7 +351,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 3;
   }
   if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".", 1)[0], 10);
     switch (env.TERM_PROGRAM) {
       case "iTerm.app": {
         return version >= 3 ? 3 : 2;
@@ -293,7 +361,7 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
       }
     }
   }
-  if (/-256(color)?$/i.test(env.TERM)) {
+  if (/-256(?:color)?$/i.test(env.TERM)) {
     return 2;
   }
   if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
@@ -326,90 +394,39 @@ var init_supports_color = __esm(() => {
   supports_color_default = supportsColor;
 });
 
-// node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
 // node_modules/chalk/source/index.js
-var exports_source = {};
-__export(exports_source, {
-  supportsColorStderr: () => stderrColor,
-  supportsColor: () => stdoutColor,
-  modifiers: () => modifierNames,
-  modifierNames: () => modifierNames,
-  foregroundColors: () => foregroundColorNames,
-  foregroundColorNames: () => foregroundColorNames,
-  default: () => source_default,
-  colors: () => colorNames,
-  colorNames: () => colorNames,
-  chalkStderr: () => chalkStderr,
-  backgroundColors: () => backgroundColorNames,
-  backgroundColorNames: () => backgroundColorNames,
-  Chalk: () => Chalk
-});
-
-class Chalk {
-  constructor(options) {
-    return chalkFactory(options);
-  }
-}
 function createChalk(options) {
   return chalkFactory(options);
 }
-var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, LEVEL, styles2, assertValidLevel = (level) => {
+  if (!Number.isSafeInteger(level) || level < 0 || level > 3) {
+    throw new Error("The `level` should be an integer from 0 to 3");
+  }
+}, levelDescriptor, applyOptions = (object, options = {}) => {
+  if (options.level !== undefined) {
+    assertValidLevel(options.level);
   }
   const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
+  object[LEVEL] = options.level === undefined ? colorLevel : options.level;
 }, chalkFactory = (options) => {
   const chalk = (...strings) => strings.join(" ");
   applyOptions(chalk, options);
   Object.setPrototypeOf(chalk, createChalk.prototype);
   return chalk;
-}, getModelAnsi = (model, level, type, ...arguments_) => {
+}, createModelConverters = (model, type) => {
+  const style = ansi_styles_default[type];
   if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+    const ansi = (red, green, blue) => style.ansi(ansi_styles_default.rgbToAnsi(red, green, blue));
+    const ansi256 = (red, green, blue) => style.ansi256(ansi_styles_default.rgbToAnsi256(red, green, blue));
+    return [ansi, ansi, ansi256, style.ansi16m];
   }
   if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+    const ansi = (hex) => style.ansi(ansi_styles_default.hexToAnsi(hex));
+    const ansi256 = (hex) => style.ansi256(ansi_styles_default.hexToAnsi256(hex));
+    return [ansi, ansi, ansi256, (hex) => style.ansi16m(...ansi_styles_default.hexToRgb(hex))];
   }
-  return ansi_styles_default[type][model](...arguments_);
+  const ansi = (code) => style.ansi(ansi_styles_default.ansi256ToAnsi(code));
+  return [ansi, ansi, style.ansi256, style.ansi256];
 }, usedModels, proto, createStyler = (open, close, parent) => {
   let openAll;
   let closeAll;
@@ -428,14 +445,22 @@ var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2
     parent
   };
 }, createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  const builder = (...arguments_) => {
+    if (arguments_.length === 1) {
+      return applyStyle(builder, "" + arguments_[0]);
+    }
+    if (arguments_.length === 2) {
+      return applyStyle(builder, arguments_[0] + " " + arguments_[1]);
+    }
+    return applyStyle(builder, arguments_.join(" "));
+  };
   Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
+  builder[GENERATOR] = self[GENERATOR] ?? self;
   builder[STYLER] = _styler;
   builder[IS_EMPTY] = _isEmpty;
   return builder;
 }, applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
+  if (self[GENERATOR][LEVEL] <= 0 || !string) {
     return self[IS_EMPTY] ? "" : string;
   }
   let styler = self[STYLER];
@@ -459,18 +484,22 @@ var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2
 var init_source = __esm(() => {
   init_ansi_styles();
   init_supports_color();
-  init_ansi_styles();
   ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
   GENERATOR = Symbol("GENERATOR");
   STYLER = Symbol("STYLER");
   IS_EMPTY = Symbol("IS_EMPTY");
-  levelMapping = [
-    "ansi",
-    "ansi",
-    "ansi256",
-    "ansi16m"
-  ];
+  LEVEL = Symbol("LEVEL");
   styles2 = Object.create(null);
+  levelDescriptor = {
+    enumerable: true,
+    get() {
+      return this[LEVEL];
+    },
+    set(level) {
+      assertValidLevel(level);
+      this[LEVEL] = level;
+    }
+  };
   Object.setPrototypeOf(createChalk.prototype, Function.prototype);
   for (const [styleName, style] of Object.entries(ansi_styles_default)) {
     styles2[styleName] = {
@@ -490,25 +519,25 @@ var init_source = __esm(() => {
   };
   usedModels = ["rgb", "hex", "ansi256"];
   for (const model of usedModels) {
-    styles2[model] = {
-      get() {
-        const { level } = this;
-        return function(...arguments_) {
-          const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-          return createBuilder(this, styler, this[IS_EMPTY]);
-        };
-      }
-    };
-    const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-    styles2[bgModel] = {
-      get() {
-        const { level } = this;
-        return function(...arguments_) {
-          const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-          return createBuilder(this, styler, this[IS_EMPTY]);
-        };
-      }
-    };
+    const capitalizedModel = model[0].toUpperCase() + model.slice(1);
+    for (const [styleName, type] of [
+      [model, "color"],
+      ["bg" + capitalizedModel, "bgColor"],
+      ["underline" + capitalizedModel, "underlineColor"]
+    ]) {
+      const { close } = ansi_styles_default[type];
+      const converters = createModelConverters(model, type);
+      styles2[styleName] = {
+        get() {
+          const styleFunction = function(first, second, third) {
+            const open = converters[this.level](first, second, third);
+            return createBuilder(this, createStyler(open, close, this[STYLER]), this[IS_EMPTY]);
+          };
+          Object.defineProperty(this, styleName, { value: styleFunction });
+          return styleFunction;
+        }
+      };
+    }
   }
   proto = Object.defineProperties(() => {}, {
     ...styles2,
@@ -522,7 +551,7 @@ var init_source = __esm(() => {
       }
     }
   });
-  Object.defineProperties(createChalk.prototype, styles2);
+  Object.defineProperties(createChalk.prototype, { ...styles2, level: levelDescriptor });
   chalk = createChalk();
   chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
   source_default = chalk;
@@ -530,6 +559,7 @@ var init_source = __esm(() => {
 
 // src/index.ts
 init_source();
+import { readFileSync as readFileSync2 } from "fs";
 
 // node_modules/citty/dist/_chunks/libs/scule.mjs
 var NUMBER_CHAR_RE = /\d/;
@@ -743,8 +773,8 @@ function parseRawArgs(args = [], opts = {}) {
   return out;
 }
 var noColor = /* @__PURE__ */ (() => {
-  const env2 = globalThis.process?.env ?? {};
-  return env2.NO_COLOR === "1" || env2.TERM === "dumb" || env2.TEST || env2.CI;
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
 })();
 var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
 var bold = /* @__PURE__ */ _c(1, 22);
@@ -1078,7 +1108,6 @@ init_source();
 import { writeFileSync, chmodSync, mkdirSync } from "fs";
 import { resolve, dirname } from "path";
 import { homedir } from "os";
-import { createInterface } from "readline/promises";
 
 // src/lib/errors.ts
 init_source();
@@ -1128,12 +1157,60 @@ function formatError(err, format) {
   hint: ${hint}` : head };
 }
 function emitError(err, format) {
-  const env2 = formatError(err, format);
-  process.stderr.write(env2.text + `
+  const env = formatError(err, format);
+  process.stderr.write(env.text + `
 `);
 }
 
+// src/commands/common.ts
+var commonArgs = {
+  format: { type: "string", description: "Output format: table | json (auto-detected by TTY)" },
+  token: { type: "string", description: "Inline access token (prefer env vars or `oura-cli login`)" },
+  db: { type: "string", description: "Path to SQLite database file (env: OURA_DB_PATH)" },
+  tz: { type: "string", description: "Display timezone (env: OURA_TZ; auto-detected)" },
+  "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.");
+  }
+  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) {
@@ -1150,37 +1227,459 @@ var loginCommand = defineCommand({
   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": { type: "boolean", default: false, description: "Disable ANSI colors (also honors NO_COLOR env)" }
+    "no-color": commonArgs["no-color"]
   },
   async run({ args }) {
-    if (args["no-color"] || process.env.NO_COLOR) {
-      const { default: chk } = await Promise.resolve().then(() => (init_source(), exports_source));
-      chk.level = 0;
-    }
-    const target = args.path ?? process.env.OURA_TOKEN_PATH ?? resolve(homedir(), ".oura-token");
-    let token = args.token;
-    if (!token) {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      console.log("Get a Personal Access Token at https://cloud.ouraring.com/personal-access-tokens");
-      token = await rl.question("Paste your token: ");
-      rl.close();
+    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);
+      }
+      writeToken(target, token);
+      console.log(source_default.green(`Saved to ${target}`));
+    } catch (err) {
+      emitError(err, "table");
+      process.exit(exitCodeFor(err));
     }
-    writeToken(target, token);
-    console.log(source_default.green(`Saved to ${target}`));
   }
 });
 
+// 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"
+  }).formatToParts(utc).find((p) => p.type === "timeZoneName")?.value ?? "GMT";
+  const m = tzPart.match(/GMT([+-])(\d{2}):(\d{2})/);
+  if (!m)
+    return 0;
+  const sign = m[1] === "+" ? 1 : -1;
+  return sign * (parseInt(m[2], 10) * 3600 + parseInt(m[3], 10) * 60) * 1000;
+}
+function localMidnightMs(day, tz) {
+  const naiveMs = new Date(`${day}T00:00:00Z`).getTime();
+  const guessMs = naiveMs - getTimezoneOffsetMs(new Date(naiveMs), tz);
+  return naiveMs - getTimezoneOffsetMs(new Date(guessMs), tz);
+}
+function localDateToUtcRange(localDate, timezone) {
+  const iso = (ms) => new Date(ms).toISOString().replace(/\.\d{3}Z$/, "Z");
+  return [iso(localMidnightMs(localDate, timezone)), iso(localMidnightMs(shiftDay(localDate, 1), timezone))];
+}
+function resolveDefaultTimezone() {
+  if (process.env.OURA_TZ)
+    return process.env.OURA_TZ;
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function today(timezone) {
+  return todayLocal(timezone ?? resolveDefaultTimezone());
+}
+function shiftDay(day, delta) {
+  const ms = new Date(`${day}T00:00:00Z`).getTime() + delta * 86400000;
+  return new Date(ms).toISOString().slice(0, 10);
+}
+function daysBack(endDay, n) {
+  const out = [];
+  for (let i = n - 1;i >= 0; i--)
+    out.push(shiftDay(endDay, -i));
+  return out;
+}
+var CALENDAR_DATE = /^\d{4}-\d{2}-\d{2}$/;
+function isCalendarDate(value) {
+  if (!CALENDAR_DATE.test(value))
+    return false;
+  const ms = new Date(`${value}T00:00:00Z`).getTime();
+  return !Number.isNaN(ms) && new Date(ms).toISOString().slice(0, 10) === value;
+}
+
+// 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 },
+    { name: "high_activity_time", type: "INTEGER", pick: (r) => r.high_activity_time },
+    { name: "medium_activity_time", type: "INTEGER", pick: (r) => r.medium_activity_time },
+    { name: "low_activity_time", type: "INTEGER", pick: (r) => r.low_activity_time },
+    { name: "sedentary_time", type: "INTEGER", pick: (r) => r.sedentary_time },
+    { name: "total_calories", type: "INTEGER", pick: (r) => r.total_calories },
+    { name: "target_calories", type: "INTEGER", pick: (r) => r.target_calories },
+    { name: "contributors", type: "TEXT", pick: (r) => JSON.stringify(r.contributors) },
+    { name: "timestamp", type: "TEXT", pick: (r) => r.timestamp }
+  ]
+});
+
+// src/collections/hr.ts
+var hr = defineCollection({
+  name: "hr",
+  endpoint: "heartrate",
+  table: "heartrate",
+  description: "Heart rate samples (bpm) with source",
+  conflict: "ignore",
+  rangeParams: "datetime",
+  maxRangeDays: 30,
+  identity: [{ field: "timestamp", format: "date-time", description: "ISO 8601 timestamp of the sample" }],
+  columns: [
+    { name: "timestamp", type: "TEXT", pick: (r) => r.timestamp },
+    { name: "bpm", type: "INTEGER", pick: (r) => r.bpm },
+    { name: "source", type: "TEXT", pick: (r) => r.source },
+    { name: "day", type: "TEXT", pick: (r) => r.timestamp.slice(0, 10) }
+  ],
+  indexes: [
+    { name: "idx_heartrate_ts", columns: ["timestamp"] },
+    { name: "idx_heartrate_unique", columns: ["timestamp", "source"], unique: true },
+    { name: "idx_heartrate_day", columns: ["day"] }
+  ]
+});
+
+// src/collections/spo2.ts
+var spo2 = defineCollection({
+  name: "spo2",
+  endpoint: "daily_spo2",
+  table: "daily_spo2",
+  description: "Daily blood-oxygen average and breathing disturbance index",
+  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: "spo2_average", type: "REAL", pick: (r) => r.spo2_percentage?.average ?? null },
+    { name: "breathing_disturbance_index", type: "REAL", pick: (r) => r.breathing_disturbance_index }
+  ]
+});
+
+// src/collections/stress.ts
+var stress = defineCollection({
+  name: "stress",
+  endpoint: "daily_stress",
+  table: "daily_stress",
+  description: "Daily stress summary with high-stress and high-recovery seconds",
+  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: "day_summary", type: "TEXT", pick: (r) => r.day_summary ?? null },
+    { name: "recovery_high", type: "INTEGER", pick: (r) => r.recovery_high },
+    { name: "stress_high", type: "INTEGER", pick: (r) => r.stress_high }
+  ]
+});
+
+// src/collections/workout.ts
+var workout = defineCollection({
+  name: "workout",
+  endpoint: "workout",
+  table: "workouts",
+  description: "Workout sessions with activity, calories, distance and intensity",
+  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", pick: (r) => r.day },
+    { name: "activity", type: "TEXT", pick: (r) => r.activity },
+    { name: "calories", type: "REAL", pick: (r) => r.calories },
+    { name: "distance", type: "REAL", pick: (r) => r.distance },
+    { name: "start_datetime", type: "TEXT", pick: (r) => r.start_datetime },
+    { name: "end_datetime", type: "TEXT", pick: (r) => r.end_datetime },
+    { name: "intensity", type: "TEXT", pick: (r) => r.intensity },
+    { name: "label", type: "TEXT", pick: (r) => r.label ?? "" },
+    { name: "source", type: "TEXT", pick: (r) => r.source }
+  ]
+});
+
+// src/collections/sleep-periods.ts
+var sleepPeriods = defineCollection({
+  name: "sleep-periods",
+  endpoint: "sleep",
+  table: "sleep_model",
+  description: "Individual sleep periods with stages, HRV, heart rate and efficiency",
+  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", pick: (r) => r.day },
+    { name: "average_breath", type: "REAL", pick: (r) => r.average_breath },
+    { name: "average_heart_rate", type: "REAL", pick: (r) => r.average_heart_rate },
+    { name: "average_hrv", type: "REAL", pick: (r) => r.average_hrv },
+    { name: "awake_time", type: "INTEGER", pick: (r) => r.awake_time },
+    { name: "bedtime_end", type: "TEXT", pick: (r) => r.bedtime_end },
+    { name: "bedtime_start", type: "TEXT", pick: (r) => r.bedtime_start },
+    { name: "deep_sleep_duration", type: "INTEGER", pick: (r) => r.deep_sleep_duration },
+    { name: "efficiency", type: "INTEGER", pick: (r) => r.efficiency },
+    { name: "latency", type: "INTEGER", pick: (r) => r.latency },
+    { name: "light_sleep_duration", type: "INTEGER", pick: (r) => r.light_sleep_duration },
+    { name: "lowest_heart_rate", type: "INTEGER", pick: (r) => r.lowest_heart_rate },
+    { name: "period", type: "INTEGER", pick: (r) => r.period },
+    { name: "rem_sleep_duration", type: "INTEGER", pick: (r) => r.rem_sleep_duration },
+    { name: "restless_periods", type: "INTEGER", pick: (r) => r.restless_periods },
+    { name: "time_in_bed", type: "INTEGER", pick: (r) => r.time_in_bed },
+    { name: "total_sleep_duration", type: "INTEGER", pick: (r) => r.total_sleep_duration },
+    { name: "type", type: "TEXT", pick: (r) => r.type ?? null }
+  ]
+});
+
+// src/collections/cv-age.ts
+var cvAge = defineCollection({
+  name: "cv-age",
+  endpoint: "daily_cardiovascular_age",
+  table: "cardiovascular_age",
+  description: "Daily cardiovascular (vascular) age estimate",
+  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: "vascular_age", type: "INTEGER", pick: (r) => r.vascular_age }
+  ]
+});
+
+// src/collections/index.ts
+var COLLECTIONS = [
+  sleep,
+  readiness,
+  activity,
+  hr,
+  spo2,
+  stress,
+  workout,
+  sleepPeriods,
+  cvAge
+];
+function names() {
+  return COLLECTIONS.map((c) => c.name);
+}
+function byName(name) {
+  return COLLECTIONS.find((c) => c.name === name);
+}
+function insertSql(c) {
+  const verb = c.conflict === "replace" ? "INSERT OR REPLACE" : "INSERT OR IGNORE";
+  const cols = c.columns.map((col) => col.name).join(", ");
+  const marks = c.columns.map(() => "?").join(", ");
+  return `${verb} INTO ${c.table} (${cols}) VALUES (${marks})`;
+}
+function rowValues(c, row) {
+  return c.columns.map((col) => col.pick(row));
+}
+var MS_PER_DAY = 86400000;
+function dateQueries(start, end, maxDays) {
+  if (!maxDays)
+    return [{ start_date: start, end_date: 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 });
+  }
+  return out;
+}
+function datetimeQueries(start, end, tz, maxDays) {
+  const from = Date.parse(localDateToUtcRange(start, tz)[0]);
+  const to = Date.parse(localDateToUtcRange(end, tz)[1]) - 1;
+  const span = (maxDays ?? Infinity) * MS_PER_DAY;
+  const out = [];
+  for (let s = from;s <= to; s += span) {
+    out.push({ start_datetime: new Date(s).toISOString(), end_datetime: new Date(Math.min(s + span - 1, to)).toISOString() });
+  }
+  return out;
+}
+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);
+}
+async function fetchCollection(client, c, start, end, tz) {
+  const rows = [];
+  for (const query of rangeQueries(c, start, end, tz)) {
+    for (const row of await client.fetch(c.endpoint, query))
+      rows.push(row);
+  }
+  return rows;
+}
+
 // src/commands/describe.ts
-function buildManifest(version) {
+var OUTPUT_SCHEMAS = { doctor: "docs/schemas/doctor.json" };
+var ENUM_ARGS = {
+  fetch: { collection: names() },
+  report: { period: ["week", "month"] }
+};
+function resolved(def) {
+  if (typeof def === "function" || def instanceof Promise) {
+    throw new Error("describe: lazy subcommands are not supported; register plain CommandDef objects.");
+  }
+  return def;
+}
+function describeArgs(command, args) {
+  const out = [];
+  for (const [key, raw] of Object.entries(args ?? {})) {
+    if (raw === commonArgs[key])
+      continue;
+    const a = raw;
+    const values = ENUM_ARGS[command]?.[key] ?? (a.type === "enum" ? [...a.options ?? []] : undefined);
+    if (a.type === "positional") {
+      out.push({
+        name: a.required ? `<${key}>` : `[${key}]`,
+        type: "string",
+        required: a.required === true,
+        description: a.description,
+        ...values ? { values } : {}
+      });
+    } else {
+      out.push({
+        name: `--${key}`,
+        type: values ? "enum" : String(a.type ?? "string"),
+        required: false,
+        description: a.description,
+        ...values ? { values } : {}
+      });
+    }
+  }
+  return out;
+}
+function resolvedMeta(meta) {
+  if (typeof meta === "function" || meta instanceof Promise)
+    return {};
+  return meta ?? {};
+}
+function describeCommandDef(name, def) {
+  const meta = resolvedMeta(def.meta);
+  const cmd = {
+    name,
+    description: meta.description ?? "",
+    args: describeArgs(name, def.args)
+  };
+  if (OUTPUT_SCHEMAS[name])
+    cmd.outputSchema = OUTPUT_SCHEMAS[name];
+  if (name === "fetch")
+    cmd.outputSchemas = Object.fromEntries(names().map((n) => [n, `docs/schemas/${n}.json`]));
+  const subs = def.subCommands;
+  if (subs) {
+    cmd.subcommands = Object.entries(subs).map(([subName, subDef]) => {
+      const sub = resolved(subDef);
+      const subMeta = resolvedMeta(sub.meta);
+      return { name: subName, description: subMeta.description ?? "", args: describeArgs(subName, sub.args) };
+    });
+  }
+  return cmd;
+}
+function buildManifest(version, commands) {
   return {
     name: "oura-cli",
     version,
     compatManifestCommand: "oura-cli manifest",
-    auth: {
-      envVars: ["OURA_TOKEN", "OURA_TOKEN_PATH"],
-      tokenFile: "~/.oura-token",
-      loginCommand: "oura-cli login"
-    },
+    auth: { envVars: ["OURA_TOKEN", "OURA_TOKEN_PATH"], tokenFile: "~/.oura-token", loginCommand: "oura-cli login" },
     globalFlags: [
       { name: "--format", type: "enum", values: ["table", "json"], description: "Output format (auto-detected by TTY when omitted)" },
       { name: "--db", type: "string", description: "Override SQLite database path (env: OURA_DB_PATH)" },
@@ -1195,396 +1694,48 @@ function buildManifest(version) {
       { code: 3, meaning: "API or network error" },
       { code: 4, meaning: "database or local storage error" }
     ],
-    commands: [
-      { name: "login", description: "Save an Oura Personal Access Token for future commands.", args: [
-        { name: "--token", type: "string", required: false, description: "Pass token non-interactively" },
-        { name: "--path", type: "string", required: false, description: "Override token file path" }
-      ] },
-      { name: "describe", description: "Emit a machine-readable manifest of commands, args, and outputs.", args: [] },
-      {
-        name: "sleep",
-        description: "Fetch daily sleep scores from Oura API. Pick a subcommand: today | date <day> | week.",
-        args: [],
-        outputSchema: "docs/schemas/sleep.json",
-        subcommands: [
-          { name: "today", description: "Today's sleep data.", args: [] },
-          { name: "date", description: "Sleep data for a specific date.", args: [{ name: "<day>", type: "date", format: "YYYY-MM-DD", required: true, description: "Target date." }] },
-          { name: "week", description: "Last 7 days of sleep data.", args: [] }
-        ]
-      },
-      {
-        name: "readiness",
-        description: "Fetch daily readiness scores from Oura API. Pick a subcommand: today | date <day> | week.",
-        args: [],
-        outputSchema: "docs/schemas/readiness.json",
-        subcommands: [
-          { name: "today", description: "Today's readiness data.", args: [] },
-          { name: "date", description: "Readiness data for a specific date.", args: [{ name: "<day>", type: "date", format: "YYYY-MM-DD", required: true, description: "Target date." }] },
-          { name: "week", description: "Last 7 days of readiness data.", args: [] }
-        ]
-      },
-      {
-        name: "activity",
-        description: "Fetch daily activity scores from Oura API. Pick a subcommand: today | date <day> | week.",
-        args: [],
-        outputSchema: "docs/schemas/activity.json",
-        subcommands: [
-          { name: "today", description: "Today's activity data.", args: [] },
-          { name: "date", description: "Activity data for a specific date.", args: [{ name: "<day>", type: "date", format: "YYYY-MM-DD", required: true, description: "Target date." }] },
-          { name: "week", description: "Last 7 days of activity data.", args: [] }
-        ]
-      },
-      {
-        name: "hr",
-        description: "Fetch heart rate samples from Oura API. Pick a subcommand: today | date <day> | week.",
-        args: [],
-        outputSchema: "docs/schemas/hr.json",
-        subcommands: [
-          { name: "today", description: "Today's heart rate data.", args: [] },
-          { name: "date", description: "Heart rate data for a specific date.", args: [{ name: "<day>", type: "date", format: "YYYY-MM-DD", required: true, description: "Target date." }] },
-          { name: "week", description: "Last 7 days of heart rate data.", args: [] }
-        ]
-      },
-      {
-        name: "spo2",
-        description: "Fetch blood oxygen (SpO2) data from Oura API. Pick a subcommand: today | date <day> | week.",
-        args: [],
-        outputSchema: "docs/schemas/spo2.json",
-        subcommands: [
-          { name: "today", description: "Today's SpO2 data.", args: [] },
-          { name: "date", description: "SpO2 data for a specific date.", args: [{ name: "<day>", type: "date", format: "YYYY-MM-DD", required: true, description: "Target date." }] },
-          { name: "week", description: "Last 7 days of SpO2 data.", args: [] }
-        ]
-      },
-      {
-        name: "stress",
-        description: "Fetch daily stress data from Oura API. Pick a subcommand: today | date <day> | week.",
-        args: [],
-        outputSchema: "docs/schemas/stress.json",
-        subcommands: [
-          { name: "today", description: "Today's stress data.", args: [] },
-          { name: "date", description: "Stress data for a specific date.", args: [{ name: "<day>", type: "date", format: "YYYY-MM-DD", required: true, description: "Target date." }] },
-          { name: "week", description: "Last 7 days of stress data.", args: [] }
-        ]
-      },
-      {
-        name: "workout",
-        description: "Fetch workout data from Oura API. Pick a subcommand: today | date <day> | week.",
-        args: [],
-        outputSchema: "docs/schemas/workout.json",
-        subcommands: [
-          { name: "today", description: "Today's workout data.", args: [] },
-          { name: "date", description: "Workout data for a specific date.", args: [{ name: "<day>", type: "date", format: "YYYY-MM-DD", required: true, description: "Target date." }] },
-          { name: "week", description: "Last 7 days of workout data.", args: [] }
-        ]
-      },
-      { name: "sync", description: "Sync all Oura collections into the local database.", args: [] },
-      {
-        name: "db",
-        description: "Query and manage the local SQLite cache. Pick a subcommand.",
-        args: [],
-        subcommands: [
-          { name: "today", description: "Today's summary from local DB.", args: [] },
-          { name: "date", description: "Summary for a specific date.", args: [{ name: "<day>", type: "date", format: "YYYY-MM-DD", required: true, description: "Target date." }] },
-          { name: "week", description: "Last 7 days from local DB.", args: [] },
-          { name: "trends", description: "Score and metric trends over N days (default 30).", args: [{ name: "[days]", type: "number", required: false, description: "Window size in days." }] },
-          { name: "stats", description: "Row counts, date range, record highs.", args: [] },
-          { name: "import", description: "Sync new data from Oura API into the local DB.", args: [] },
-          { name: "reset", description: "Destroy and rebuild the database from exported CSVs.", args: [] }
-        ]
-      },
-      {
-        name: "report",
-        description: "Generate a narrative health report from local data.",
-        args: [
-          { name: "--period", type: "enum", values: ["week", "month"], description: "Report window (default week)." }
-        ]
-      }
-    ]
+    commands: Object.entries(commands).map(([name, def]) => describeCommandDef(name, resolved(def)))
   };
 }
-function describeCommand(version) {
+function describeCommand(version, getCommands) {
   return defineCommand({
     meta: { name: "describe", description: "Emit a machine-readable manifest of commands, args, and outputs." },
     args: {},
     run() {
-      console.log(JSON.stringify(buildManifest(version), null, 2));
+      console.log(JSON.stringify(buildManifest(version, getCommands()), null, 2));
     }
   });
 }
 
-// src/commands/sync.ts
-import { mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2 } from "path";
-
-// src/lib/db.ts
-import { Database } from "bun:sqlite";
-import { resolve as resolve2 } from "path";
-import { homedir as homedir2 } from "os";
-import { mkdirSync as mkdirSync2 } from "fs";
-function getDbPath(options = {}) {
-  if (options.dbPath)
-    return options.dbPath;
-  if (options.envVar && process.env[options.envVar])
-    return process.env[options.envVar];
-  const dir = options.defaultDir ?? ".oura-cli";
-  const file = options.defaultFile ?? "oura.db";
-  return resolve2(homedir2(), dir, file);
-}
-function openDatabase(options = {}) {
-  const dbPath = getDbPath(options);
-  if (dbPath !== ":memory:") {
-    mkdirSync2(resolve2(dbPath, ".."), { recursive: true });
+// src/db/sync.ts
+var BACKFILL_DAYS = 30;
+var FRESHNESS_TABLES = ["daily_sleep", "daily_readiness", "daily_activity"];
+async function importDaily(db, client, clock, log) {
+  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 db = new Database(dbPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  return db;
-}
-function getSchemaVersion(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) {
-  const current = getSchemaVersion(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);
-    }
+  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 stmt = db.query(insertSql(c));
+    db.transaction((rs) => {
+      for (const r of rs)
+        stmt.run(...rowValues(c, r));
+    })(rows);
+    counts[c.table] = rows.length;
+    if (rows.length > 0)
+      _log(`  + ${c.table}: ${rows.length} rows`);
   }
-}
-
-// src/db/schema.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/database.ts
-var DB_OPTIONS = {
-  envVar: "OURA_DB_PATH",
-  defaultDir: ".oura-cli",
-  defaultFile: "oura.db"
-};
-function getDbPath2(options = {}) {
-  return getDbPath({ ...DB_OPTIONS, ...options });
-}
-function openDatabase2(options = {}) {
-  return openDatabase({ ...DB_OPTIONS, ...options });
-}
-function ensureSchema2(db) {
-  ensureSchema(db, MIGRATIONS);
-}
-
-// src/db/import.ts
-async function importDaily(db, client, log) {
-  const _log = log ?? (() => {});
-  const today = new Date().toISOString().slice(0, 10);
-  const lastDates = [];
-  for (const tbl of ["daily_sleep", "daily_readiness", "daily_activity"]) {
-    const row = db.query(`SELECT MAX(day) as d FROM ${tbl}`).get();
-    if (row?.d)
-      lastDates.push(row.d);
-  }
-  const startDate = lastDates.length > 0 ? lastDates.sort()[0] : new Date(Date.now() - 30 * 86400000).toISOString().slice(0, 10);
-  _log(`Syncing from ${startDate} to ${today}`);
-  const counts = {};
-  const sleepData = await client.fetch("daily_sleep", startDate, today);
-  const insertSleep = db.query("INSERT OR REPLACE INTO daily_sleep VALUES (?,?,?,?,?)");
-  for (const s of sleepData) {
-    insertSleep.run(s.id, s.day, s.score, JSON.stringify(s.contributors), s.timestamp);
-    _log(`  + sleep ${s.day}`);
-  }
-  counts.daily_sleep = sleepData.length;
-  const readinessData = await client.fetch("daily_readiness", startDate, today);
-  const insertReadiness = db.query("INSERT OR REPLACE INTO daily_readiness VALUES (?,?,?,?,?,?,?)");
-  for (const r of readinessData) {
-    insertReadiness.run(r.id, r.day, r.score, JSON.stringify(r.contributors), r.temperature_deviation, r.temperature_trend_deviation, r.timestamp);
-    _log(`  + readiness ${r.day}`);
-  }
-  counts.daily_readiness = readinessData.length;
-  const activityData = await client.fetch("daily_activity", startDate, today);
-  const insertActivity = db.query("INSERT OR REPLACE INTO daily_activity VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
-  for (const a of activityData) {
-    insertActivity.run(a.id, a.day, a.score, a.active_calories, a.steps, a.equivalent_walking_distance, a.high_activity_time, a.medium_activity_time, a.low_activity_time, a.sedentary_time, a.total_calories, a.target_calories, JSON.stringify(a.contributors), a.timestamp);
-    _log(`  + activity ${a.day}`);
-  }
-  counts.daily_activity = activityData.length;
-  const hrData = await client.fetch("heartrate", today, today);
-  const insertHr = db.query("INSERT OR IGNORE INTO heartrate VALUES (?,?,?,?)");
-  for (const h of hrData) {
-    const day = h.timestamp.slice(0, 10);
-    insertHr.run(h.timestamp, h.bpm, h.source, day);
-  }
-  counts.heartrate = hrData.length;
-  if (hrData.length > 0)
-    _log(`  + heartrate ${hrData.length} records`);
-  const spo2Data = await client.fetch("daily_spo2", startDate, today);
-  const insertSpo2 = db.query("INSERT OR REPLACE INTO daily_spo2 VALUES (?,?,?,?)");
-  for (const s of spo2Data) {
-    const avg = s.spo2_percentage?.average ?? null;
-    insertSpo2.run(s.id, s.day, avg, s.breathing_disturbance_index);
-    _log(`  + spo2 ${s.day}`);
-  }
-  counts.daily_spo2 = spo2Data.length;
-  const stressData = await client.fetch("daily_stress", startDate, today);
-  const insertStress = db.query("INSERT OR REPLACE INTO daily_stress VALUES (?,?,?,?,?)");
-  for (const s of stressData) {
-    insertStress.run(s.id, s.day, s.day_summary, s.recovery_high, s.stress_high);
-    _log(`  + stress ${s.day}`);
-  }
-  counts.daily_stress = stressData.length;
-  const workoutData = await client.fetch("workout", startDate, today);
-  const insertWorkout = db.query("INSERT OR REPLACE INTO workouts VALUES (?,?,?,?,?,?,?,?,?,?)");
-  for (const w of workoutData) {
-    insertWorkout.run(w.id, w.day, w.activity, w.calories, w.distance, w.start_datetime, w.end_datetime, w.intensity, w.label ?? "", w.source);
-    _log(`  + workout ${w.day} ${w.activity}`);
-  }
-  counts.workouts = workoutData.length;
-  const sleepPeriods = await client.fetch("sleep", startDate, today);
-  const insertSleepModel = db.query(`INSERT OR REPLACE INTO sleep_model VALUES (${Array(19).fill("?").join(",")})`);
-  for (const sp of sleepPeriods) {
-    insertSleepModel.run(sp.id, sp.day, sp.average_breath, sp.average_heart_rate, sp.average_hrv, sp.awake_time, sp.bedtime_end, sp.bedtime_start, sp.deep_sleep_duration, sp.efficiency, sp.latency, sp.light_sleep_duration, sp.lowest_heart_rate, sp.period, sp.rem_sleep_duration, sp.restless_periods, sp.time_in_bed, sp.total_sleep_duration, sp.type);
-    _log(`  + sleep_period ${sp.day} (${sp.type})`);
-  }
-  counts.sleep_model = sleepPeriods.length;
-  const cvData = await client.fetch("daily_cardiovascular_age", startDate, today);
-  const insertCv = db.query("INSERT OR REPLACE INTO cardiovascular_age VALUES (?,?,?)");
-  for (const c of cvData) {
-    insertCv.run(c.id, c.day, c.vascular_age);
-    _log(`  + cardiovascular_age ${c.day}`);
-  }
-  counts.cardiovascular_age = cvData.length;
-  _log("Import complete.");
-  return { startDate, endDate: today, counts };
+  _log("Import complete.");
+  return { startDate, endDate: today, counts, isFirstSync };
 }
 
 // src/db/queries.ts
@@ -1612,9 +1763,8 @@ function getDaySummary(db, day) {
     efficiency: sm?.efficiency ?? null
   };
 }
-function getTrends(db, days) {
-  const today = new Date().toISOString().slice(0, 10);
-  const start = new Date(Date.now() - days * 86400000).toISOString().slice(0, 10);
+function getTrends(db, days, today) {
+  const start = shiftDay(today, -days);
   const results = [];
   const metrics = [
     ["Sleep Score", "daily_sleep", "score"],
@@ -1635,25 +1785,13 @@ function getTrends(db, days) {
   }
   return results;
 }
-function getStats(db) {
-  const tableNames = [
-    "daily_sleep",
-    "daily_readiness",
-    "daily_activity",
-    "daily_spo2",
-    "daily_stress",
-    "heartrate",
-    "vo2max",
-    "cardiovascular_age",
-    "workouts",
-    "sleep_model"
-  ];
-  const tables = tableNames.map((table) => {
-    const row = db.query(`SELECT COUNT(*) as cnt FROM ${table}`).get();
-    return { table, rows: row.cnt };
+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);
+  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 {
@@ -1667,7 +1805,7 @@ function getStats(db) {
   };
 }
 
-// src/format.ts
+// src/render/format.ts
 init_source();
 function scoreColor(score) {
   if (score === null)
@@ -1683,9 +1821,22 @@ function fmtHours(h) {
     return source_default.gray("\u2014");
   return `${h}h`;
 }
-function formatDaySummary(summary, format) {
+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}`),
@@ -1709,9 +1860,26 @@ function formatDaySummary(summary, format) {
   return lines.join(`
 `);
 }
-function formatWeekTable(days, format) {
+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)}`);
@@ -1762,32 +1930,236 @@ function formatStats(stats, format) {
 `);
 }
 
-// src/api/client.ts
+// 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 direct = options.token ?? process.env.OURA_TOKEN;
-    if (direct) {
-      this.token = direct.trim();
-    } else {
-      const tokenPath = options.tokenPath ?? process.env.OURA_TOKEN_PATH ?? resolve3(homedir3(), ".oura-token");
-      try {
-        this.token = readFileSync(tokenPath, "utf-8").trim();
-      } catch {
-        throw new CliError("TOKEN_MISSING", `No Oura access token at ${tokenPath}.`, "Run `oura-cli login` or set OURA_TOKEN.");
-      }
+    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 fetch(endpoint, startDate, endDate) {
-    const params = new URLSearchParams({ start_date: startDate });
-    if (endDate)
-      params.set("end_date", endDate);
-    const url = `${BASE_URL}/${endpoint}?${params}`;
+  async getPage(url) {
     const response = await fetch(url, {
       headers: { Authorization: `Bearer ${this.token}` }
     });
@@ -1806,59 +2178,11 @@ class OuraClient {
     } catch {
       throw new CliError("API_ERROR", "Empty response body from Oura API.");
     }
-    return json.data ?? [];
+    const body = json;
+    return { data: body.data ?? [], next_token: body.next_token ?? null };
   }
 }
 
-// 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 resolveDefaultTimezone() {
-  if (process.env.OURA_TZ)
-    return process.env.OURA_TZ;
-  try {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-  } catch {
-    return "UTC";
-  }
-}
-
-// src/commands/helpers.ts
-function getClient(opts) {
-  return new OuraClient(opts.token ? { token: opts.token } : {});
-}
-function todayDate(timezone) {
-  return todayLocal(timezone ?? resolveDefaultTimezone());
-}
-function dateRange(days, timezone) {
-  const tz = timezone ?? resolveDefaultTimezone();
-  const end = todayLocal(tz);
-  const startMs = new Date(`${end}T00:00:00Z`).getTime() - (days - 1) * 86400000;
-  const start = new Date(startMs).toISOString().slice(0, 10);
-  return { start, end };
-}
-
 // src/lib/format-resolve.ts
 function resolveFormat({ explicit, isTty }) {
   if (explicit === undefined)
@@ -1868,341 +2192,146 @@ function resolveFormat({ explicit, isTty }) {
   throw new CliError("BAD_ARGS", `Unknown --format value: "${explicit}". Use "table" or "json".`);
 }
 
-// src/commands/common.ts
-var commonArgs = {
-  format: { type: "string", description: "Output format: table | json (auto-detected by TTY)" },
-  token: { type: "string", description: "Inline access token (prefer env vars or `oura-cli login`)" },
-  db: { type: "string", description: "Path to SQLite database file (env: OURA_DB_PATH)" },
-  tz: { type: "string", description: "Display timezone (env: OURA_TZ; auto-detected)" },
-  "no-color": { type: "boolean", default: false, description: "Disable ANSI colors (also honors NO_COLOR env)" }
-};
-function handleError(err, args) {
-  const fmt = resolveFormat({
-    explicit: args.format,
-    isTty: process.stdout.isTTY === true
-  });
-  emitError(err, fmt);
-  process.exit(exitCodeFor(err));
-}
-function applyNoColor(args) {
-  if (args["no-color"] || process.env.NO_COLOR) {
-    Promise.resolve().then(() => (init_source(), exports_source)).then(({ default: chalk2 }) => {
-      chalk2.level = 0;
-    });
+// 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/commands/sync.ts
-async function runSync(opts) {
-  const format = resolveFormat({ explicit: opts.format, isTty: process.stdout.isTTY === true });
-  const dbPath = getDbPath2({ dbPath: opts.db });
-  mkdirSync3(dirname2(dbPath), { recursive: true });
-  const db = openDatabase2({ dbPath: opts.db });
-  ensureSchema2(db);
-  const client = getClient(opts);
-  const log = format === "table" ? console.log : undefined;
-  const importResult = await importDaily(db, client, log);
-  const today = getDaySummary(db, todayDate(opts.tz));
-  db.close();
-  if (format === "json") {
-    console.log(JSON.stringify({ import: importResult, today }, null, 2));
-  } else {
-    console.log(formatDaySummary(today, format));
+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;
 }
-var syncCommand = defineCommand({
-  meta: { name: "sync", description: "Import latest data from Oura API and return today's summary" },
-  args: { ...commonArgs },
-  async run({ args }) {
-    applyNoColor(args);
-    try {
-      await runSync({ format: args.format, db: args.db, token: args.token, tz: args.tz });
-    } catch (err) {
-      handleError(err, args);
-    }
+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/commands/db.ts
-import { mkdirSync as mkdirSync4, unlinkSync } from "fs";
-import { dirname as dirname3 } from "path";
-
-// src/db/csv-import.ts
-import { readFileSync as readFileSync2, existsSync } from "fs";
-import { join } from "path";
-var CSV_DIR = join(process.env.HOME ?? "", "Documents/OpenClaw/projects/oura-ring/data/App Data");
-function parseCSV(filename) {
-  const path = join(CSV_DIR, filename);
-  if (!existsSync(path))
-    return [];
-  const text = readFileSync2(path, "utf-8");
-  const lines = text.split(`
-`).filter((l) => l.trim());
-  if (lines.length < 2)
-    return [];
-  const headers = lines[0].split(";");
-  return lines.slice(1).map((line) => {
-    const vals = line.split(";");
-    const row = {};
-    headers.forEach((h, i) => {
-      row[h] = vals[i] ?? "";
-    });
-    return row;
-  });
-}
-function num(v) {
-  if (!v || v === "")
-    return null;
-  const n = Number(v);
-  return isNaN(n) ? null : n;
 }
-function str(v) {
-  return v && v !== "" ? v : null;
-}
-function importFromCSV(db, log) {
-  if (!existsSync(CSV_DIR)) {
-    throw new Error(`CSV directory not found: ${CSV_DIR}`);
-  }
-  const sleep = parseCSV("dailysleep.csv");
-  const insertSleep = db.query("INSERT OR REPLACE INTO daily_sleep VALUES (?,?,?,?,?)");
-  const sleepTx = db.transaction(() => {
-    for (const r of sleep)
-      insertSleep.run(r.id, r.day, num(r.score), str(r.contributors), str(r.timestamp));
-  });
-  sleepTx();
-  log(`daily_sleep: ${sleep.length} rows`);
-  const readiness = parseCSV("dailyreadiness.csv");
-  const insertReadiness = db.query("INSERT OR REPLACE INTO daily_readiness VALUES (?,?,?,?,?,?,?)");
-  const readinessTx = db.transaction(() => {
-    for (const r of readiness)
-      insertReadiness.run(r.id, r.day, num(r.score), str(r.contributors), num(r.temperature_deviation), num(r.temperature_trend_deviation), str(r.timestamp));
-  });
-  readinessTx();
-  log(`daily_readiness: ${readiness.length} rows`);
-  const activity = parseCSV("dailyactivity.csv");
-  const insertActivity = db.query("INSERT OR REPLACE INTO daily_activity VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
-  const activityTx = db.transaction(() => {
-    for (const r of activity)
-      insertActivity.run(r.id, r.day, num(r.score), num(r.active_calories), num(r.steps), num(r.equivalent_walking_distance), num(r.high_activity_time), num(r.medium_activity_time), num(r.low_activity_time), num(r.sedentary_time), num(r.total_calories), num(r.target_calories), str(r.contributors), str(r.timestamp));
-  });
-  activityTx();
-  log(`daily_activity: ${activity.length} rows`);
-  const spo2 = parseCSV("dailyspo2.csv");
-  const insertSpo2 = db.query("INSERT OR REPLACE INTO daily_spo2 VALUES (?,?,?,?)");
-  const spo2Tx = db.transaction(() => {
-    for (const r of spo2) {
-      let avg = null;
-      try {
-        const parsed = JSON.parse(r.spo2_percentage);
-        avg = parsed?.average ?? null;
-      } catch {}
-      insertSpo2.run(r.id, r.day, avg, num(r.breathing_disturbance_index));
+
+// 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
+};
+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;
     }
-  });
-  spo2Tx();
-  log(`daily_spo2: ${spo2.length} rows`);
-  const stress = parseCSV("dailystress.csv");
-  const insertStress = db.query("INSERT OR REPLACE INTO daily_stress VALUES (?,?,?,?,?)");
-  const stressTx = db.transaction(() => {
-    for (const r of stress)
-      insertStress.run(r.id, r.day, str(r.day_summary), num(r.recovery_high), num(r.stress_high));
-  });
-  stressTx();
-  log(`daily_stress: ${stress.length} rows`);
-  const hr = parseCSV("heartrate.csv");
-  const insertHr = db.query("INSERT OR IGNORE INTO heartrate VALUES (?,?,?,?)");
-  const hrTx = db.transaction(() => {
-    for (const r of hr) {
-      const day = r.timestamp?.slice(0, 10) ?? null;
-      insertHr.run(r.timestamp, num(r.bpm), str(r.source), day);
+    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);
+}
+function dataCommand(def) {
+  return defineCommand({
+    meta: def.meta,
+    args: { ...commonArgs, ...def.args ?? {} },
+    run: ({ args }) => execute(def, args, processIo)
   });
-  hrTx();
-  log(`heartrate: ${hr.length} rows`);
-  const sleepModel = parseCSV("sleepmodel.csv");
-  const insertSM = db.query("INSERT OR REPLACE INTO sleep_model VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
-  const smTx = db.transaction(() => {
-    for (const r of sleepModel)
-      insertSM.run(r.id, r.day, num(r.average_breath), num(r.average_heart_rate), num(r.average_hrv), num(r.awake_time), str(r.bedtime_end), str(r.bedtime_start), num(r.deep_sleep_duration), num(r.efficiency), num(r.latency), num(r.light_sleep_duration), num(r.lowest_heart_rate), num(r.period), num(r.rem_sleep_duration), num(r.restless_periods), num(r.time_in_bed), num(r.total_sleep_duration), str(r.type));
-  });
-  smTx();
-  log(`sleep_model: ${sleepModel.length} rows`);
-  const vo2 = parseCSV("vo2max.csv");
-  const insertVo2 = db.query("INSERT OR REPLACE INTO vo2max VALUES (?,?,?,?)");
-  const vo2Tx = db.transaction(() => {
-    for (const r of vo2)
-      insertVo2.run(r.id, r.day, num(r.vo2_max), str(r.timestamp));
-  });
-  vo2Tx();
-  log(`vo2max: ${vo2.length} rows`);
-  const cv = parseCSV("dailycardiovascularage.csv");
-  const insertCv = db.query("INSERT OR REPLACE INTO cardiovascular_age VALUES (?,?,?)");
-  const cvTx = db.transaction(() => {
-    for (const r of cv)
-      insertCv.run(r.id, r.day, num(r.vascular_age));
-  });
-  cvTx();
-  log(`cardiovascular_age: ${cv.length} rows`);
-  const workouts = parseCSV("workout.csv");
-  const insertW = db.query("INSERT OR REPLACE INTO workouts VALUES (?,?,?,?,?,?,?,?,?,?)");
-  const wTx = db.transaction(() => {
-    for (const r of workouts)
-      insertW.run(r.id, r.day, str(r.activity), num(r.calories), num(r.distance), str(r.start_datetime), str(r.end_datetime), str(r.intensity), str(r.label), str(r.source));
-  });
-  wTx();
-  log(`workouts: ${workouts.length} rows`);
-  log("CSV import complete.");
 }
 
+// src/commands/sync.ts
+async function runSync(ctx) {
+  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 today = getDaySummary(ctx.db, ctx.today);
+  return {
+    json: { import: importResult, today },
+    text: () => [...lines, formatImportSummary(importResult), formatDaySummary(today, "table")].join(`
+`)
+  };
+}
+var syncCommand = dataCommand({
+  meta: { name: "sync", description: "Import latest data from Oura API and return today's summary" },
+  needs: { db: true, client: true },
+  run: runSync
+});
+
 // src/commands/db.ts
+var SYNC_HINT = "Run `oura-cli sync` to download your data. Oura publishes a day's summary after that night's sleep syncs from the ring.";
 var dbCommand = defineCommand({
   meta: { name: "db", description: "Query and manage the local SQLite database" },
   subCommands: {
-    import: defineCommand({
-      meta: { name: "import", description: "Sync new data from Oura API into local database (alias of sync)" },
-      args: { ...commonArgs },
-      async run({ args }) {
-        applyNoColor(args);
-        try {
-          await runSync({ format: args.format, db: args.db, token: args.token, tz: args.tz });
-        } catch (err) {
-          handleError(err, args);
-        }
-      }
-    }),
-    today: defineCommand({
+    today: dataCommand({
       meta: { name: "today", description: "Today's summary from local database" },
-      args: { ...commonArgs },
-      run({ args }) {
-        applyNoColor(args);
-        try {
-          const format = resolveFormat({ explicit: args.format, isTty: process.stdout.isTTY === true });
-          const db = openDatabase2({ dbPath: args.db });
-          ensureSchema2(db);
-          const summary = getDaySummary(db, todayDate(args.tz));
-          console.log(formatDaySummary(summary, format));
-          db.close();
-        } catch (err) {
-          handleError(err, args);
-        }
+      needs: { db: true },
+      run(ctx) {
+        const summary = getDaySummary(ctx.db, ctx.today);
+        return { json: summary, text: () => formatDaySummary(summary, "table", SYNC_HINT) };
       }
     }),
-    date: defineCommand({
+    date: dataCommand({
       meta: { name: "date", description: "Summary for specific date from local database" },
-      args: {
-        ...commonArgs,
-        day: { type: "positional", required: true, description: "Target date (YYYY-MM-DD)" }
-      },
-      run({ args }) {
-        applyNoColor(args);
-        try {
-          const format = resolveFormat({ explicit: args.format, isTty: process.stdout.isTTY === true });
-          const db = openDatabase2({ dbPath: args.db });
-          ensureSchema2(db);
-          const summary = getDaySummary(db, args.day);
-          console.log(formatDaySummary(summary, format));
-          db.close();
-        } catch (err) {
-          handleError(err, args);
-        }
+      args: { day: { type: "positional", required: true, description: "Target date (YYYY-MM-DD)" } },
+      needs: { db: true },
+      run(ctx, args) {
+        const day = assertCalendarDate(String(args.day), "<day>");
+        const summary = getDaySummary(ctx.db, day);
+        return { json: summary, text: () => formatDaySummary(summary, "table") };
       }
     }),
-    week: defineCommand({
+    week: dataCommand({
       meta: { name: "week", description: "Last 7 days from local database" },
-      args: { ...commonArgs },
-      run({ args }) {
-        applyNoColor(args);
-        try {
-          const format = resolveFormat({ explicit: args.format, isTty: process.stdout.isTTY === true });
-          const db = openDatabase2({ dbPath: args.db });
-          ensureSchema2(db);
-          const days = [];
-          for (let i = 6;i >= 0; i--) {
-            const d = new Date(Date.now() - i * 86400000).toISOString().slice(0, 10);
-            days.push(getDaySummary(db, d));
-          }
-          console.log(formatWeekTable(days, format));
-          db.close();
-        } catch (err) {
-          handleError(err, args);
-        }
+      needs: { db: true },
+      run(ctx) {
+        const days = daysBack(ctx.today, 7).map((d) => getDaySummary(ctx.db, d));
+        return { json: days, text: () => formatWeekTable(days, "table", "Run `oura-cli sync`, then `oura-cli db week` again.") };
       }
     }),
-    trends: defineCommand({
+    trends: dataCommand({
       meta: { name: "trends", description: "Score and metric trends over N days (default: 30)" },
-      args: {
-        ...commonArgs,
-        days: { type: "positional", required: false, description: "Window size in days (default: 30)" }
-      },
-      run({ args }) {
-        applyNoColor(args);
-        try {
-          const format = resolveFormat({ explicit: args.format, isTty: process.stdout.isTTY === true });
-          const n = args.days ? parseInt(args.days, 10) : 30;
-          const db = openDatabase2({ dbPath: args.db });
-          ensureSchema2(db);
-          const trends = getTrends(db, n);
-          console.log(formatTrends(trends, n, format));
-          db.close();
-        } catch (err) {
-          handleError(err, args);
-        }
+      args: { days: { type: "positional", required: false, description: "Window size in days (default: 30)" } },
+      needs: { db: true },
+      run(ctx, args) {
+        const n = args.days === undefined ? 30 : assertPositiveInt(String(args.days), "<days>");
+        const trends = getTrends(ctx.db, n, ctx.today);
+        return { json: trends, text: () => formatTrends(trends, n, "table") };
       }
     }),
-    stats: defineCommand({
+    stats: dataCommand({
       meta: { name: "stats", description: "Row counts, date range, and record highs from local database" },
-      args: { ...commonArgs },
-      run({ args }) {
-        applyNoColor(args);
-        try {
-          const format = resolveFormat({ explicit: args.format, isTty: process.stdout.isTTY === true });
-          const db = openDatabase2({ dbPath: args.db });
-          ensureSchema2(db);
-          const stats = getStats(db);
-          console.log(formatStats(stats, format));
-          db.close();
-        } catch (err) {
-          handleError(err, args);
-        }
-      }
-    }),
-    reset: defineCommand({
-      meta: { name: "reset", description: "Destroy and rebuild database from exported CSV files" },
-      args: {
-        ...commonArgs,
-        force: { type: "boolean", default: false, description: "Confirm destructive reset" }
-      },
-      run({ args }) {
-        applyNoColor(args);
-        try {
-          if (!args.force) {
-            console.log(JSON.stringify({ error: "Use --force to confirm destructive reset." }));
-            process.exit(1);
-          }
-          const format = resolveFormat({ explicit: args.format, isTty: process.stdout.isTTY === true });
-          const dbPath = getDbPath2({ dbPath: args.db });
-          try {
-            unlinkSync(dbPath);
-          } catch {}
-          try {
-            unlinkSync(dbPath + "-wal");
-          } catch {}
-          try {
-            unlinkSync(dbPath + "-shm");
-          } catch {}
-          const log = format === "table" ? console.log : undefined;
-          log?.("Database deleted.");
-          mkdirSync4(dirname3(dbPath), { recursive: true });
-          const db = openDatabase2({ dbPath: args.db });
-          ensureSchema2(db);
-          importFromCSV(db, log ?? (() => {}));
-          if (format === "json") {
-            console.log(JSON.stringify({ status: "reset complete" }));
-          }
-          db.close();
-        } catch (err) {
-          handleError(err, args);
-        }
+      needs: { db: true },
+      run(ctx) {
+        const stats = getStats(ctx.db, ctx.today);
+        return { json: stats, text: () => formatStats(stats, "table") };
       }
     })
   }
@@ -2217,17 +2346,15 @@ function dayLabel(dateStr) {
   const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
   return `${day} ${dd}/${mm}`;
 }
-function getReport(db, days) {
+function getReport(db, days, today) {
   const period = days <= 7 ? "week" : "month";
-  const today = new Date;
-  const weekEnd = today.toISOString().slice(0, 10);
-  const weekStartDate = new Date(today.getTime() - (days - 1) * 86400000);
-  const weekStart = weekStartDate.toISOString().slice(0, 10);
-  const prevWeekEnd = new Date(today.getTime() - days * 86400000).toISOString().slice(0, 10);
-  const prevWeekStart = new Date(today.getTime() - (days * 2 - 1) * 86400000).toISOString().slice(0, 10);
+  const weekEnd = today;
+  const weekStart = shiftDay(today, -(days - 1));
+  const prevWeekEnd = shiftDay(today, -days);
+  const prevWeekStart = shiftDay(today, -(days * 2 - 1));
   const dailyRows = [];
   for (let i = days - 1;i >= 0; i--) {
-    const d = new Date(today.getTime() - i * 86400000).toISOString().slice(0, 10);
+    const d = shiftDay(today, -i);
     const sl = db.query("SELECT score FROM daily_sleep WHERE day=?").get(d);
     const rd = db.query("SELECT score FROM daily_readiness WHERE day=?").get(d);
     const ac = db.query("SELECT score, steps FROM daily_activity WHERE day=?").get(d);
@@ -2295,7 +2422,7 @@ function getReport(db, days) {
   return { period, weekStart, weekEnd, days: dailyRows, averages, spo2, patterns: { lowSleep, lowReadiness, highActivity }, sleepDetails, recommendations };
 }
 
-// src/format-report.ts
+// src/render/format-report.ts
 init_source();
 function colorizeScore(n) {
   if (n >= 85)
@@ -2365,6 +2492,14 @@ function formatReport(data, format, period) {
   }
   lines.push(source_default.gray(`  ${data.weekStart} \u2014 ${data.weekEnd}`));
   lines.push("");
+  const hasReportData = data.days.some((day) => day.sleep !== null || day.readiness !== null || day.activity !== null || day.steps !== null) || data.averages.length > 0 || data.spo2 !== null || data.sleepDetails !== null;
+  if (!hasReportData) {
+    lines.push("  No Oura data is available for this report yet.");
+    lines.push("  Run `oura-cli sync` to download your data, then run `oura-cli report` again.");
+    lines.push("");
+    return lines.join(`
+`);
+  }
   if (period === "week") {
     lines.push(source_default.bold("  Last 7 Days:"));
     lines.push(source_default.gray("  " + "\u2500".repeat(52)));
@@ -2436,29 +2571,17 @@ function formatReport(data, format, period) {
 }
 
 // src/commands/report.ts
-var reportCommand = defineCommand({
+var reportCommand = dataCommand({
   meta: { name: "report", description: "Generate a narrative health report from local data." },
-  args: {
-    ...commonArgs,
-    period: { type: "string", description: "Report window: week | month", default: "week" }
-  },
-  run({ args }) {
-    applyNoColor(args);
-    try {
-      const period = args.period;
-      if (period !== "week" && period !== "month") {
-        throw new CliError("BAD_ARGS", `--period must be "week" or "month", got "${period}".`);
-      }
-      const format = resolveFormat({ explicit: args.format, isTty: process.stdout.isTTY === true });
-      const db = openDatabase2({ dbPath: args.db });
-      ensureSchema2(db);
-      const days = period === "week" ? 7 : 30;
-      const data = getReport(db, days);
-      console.log(formatReport(data, format, period));
-      db.close();
-    } catch (err) {
-      handleError(err, args);
+  args: { period: { type: "string", description: "Report window: week | month", default: "week" } },
+  needs: { db: true },
+  run(ctx, args) {
+    const period = args.period;
+    if (period !== "week" && period !== "month") {
+      throw new CliError("BAD_ARGS", `--period must be "week" or "month", got "${period}".`);
     }
+    const data = getReport(ctx.db, period === "week" ? 7 : 30, ctx.today);
+    return { json: data, text: () => formatReport(data, "table", period) };
   }
 });
 
@@ -2472,8 +2595,8 @@ function healthcheckCommand(version) {
       let ok = true;
       let error;
       try {
-        const db = openDatabase2({ dbPath: args.db });
-        ensureSchema2(db);
+        const db = openDatabase(args.db);
+        ensureSchema(db);
         db.query("SELECT 1").get();
         db.close();
       } catch (err) {
@@ -2485,96 +2608,209 @@ function healthcheckCommand(version) {
   });
 }
 
+// src/render/doctor-table.ts
+init_source();
+function statusSymbol(status) {
+  if (status === "ok")
+    return source_default.green("\u2713");
+  if (status === "warn")
+    return source_default.yellow("!");
+  return source_default.red("\u2717");
+}
+function formatDoctorTable(result) {
+  const lines = ["", source_default.bold("  Doctor"), source_default.gray("\u2500".repeat(50))];
+  for (const c of result.checks) {
+    lines.push(`  ${statusSymbol(c.status)} ${c.id.padEnd(12)} ${c.detail}`);
+  }
+  lines.push("");
+  const next = result.nextStep ?? (result.ok ? "nothing \u2014 everything looks healthy." : "see the failing checks above.");
+  lines.push(`  Next: ${next}`);
+  return lines.join(`
+`);
+}
+
+// src/commands/doctor.ts
+async function runChecks(deps) {
+  const checks = [];
+  const { token, source } = deps.resolveToken();
+  if (token) {
+    checks.push({ id: "token", status: "ok", detail: `Token found via ${source}.` });
+  } else {
+    checks.push({ id: "token", status: "fail", detail: `No token found (checked ${source}).`, fix: "oura-cli login" });
+  }
+  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)." });
+  } else {
+    try {
+      const client = deps.createClient(token);
+      await client.fetch("daily_sleep", { start_date: deps.today, end_date: deps.today });
+      checks.push({ id: "token-valid", status: "ok", detail: "Token accepted by the Oura API." });
+    } catch (err) {
+      if (err instanceof CliError && err.code === "TOKEN_INVALID") {
+        checks.push({ id: "token-valid", status: "fail", detail: err.message, fix: "oura-cli login" });
+      } else {
+        const msg = err instanceof Error ? err.message : String(err);
+        checks.push({ id: "token-valid", status: "warn", detail: `Could not reach the Oura API: ${msg}` });
+      }
+    }
+  }
+  let db = null;
+  try {
+    const opened = deps.openDb();
+    db = opened.db;
+    checks.push({ id: "database", status: "ok", detail: `Database ready at ${opened.path}.` });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    checks.push({ id: "database", status: "fail", detail: msg });
+  }
+  if (db) {
+    const last = latestDataDay(db);
+    if (!last) {
+      checks.push({ id: "data", status: "warn", detail: "No data in the local cache yet.", fix: "oura-cli sync" });
+    } else {
+      const ageDays = Math.round((new Date(`${deps.today}T00:00:00Z`).getTime() - new Date(`${last}T00:00:00Z`).getTime()) / 86400000);
+      if (ageDays > 2) {
+        checks.push({ id: "data", status: "warn", detail: `Most recent data is from ${last} (${ageDays} days ago).`, fix: "oura-cli sync" });
+      } else {
+        checks.push({ id: "data", status: "ok", detail: `Data current through ${last}.` });
+      }
+    }
+  } else {
+    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;
+  return { ok, checks, nextStep };
+}
+var DATA_TABLES = ["daily_sleep", "daily_readiness", "daily_activity"];
+function latestDataDay(db) {
+  let latest = null;
+  for (const tbl of DATA_TABLES) {
+    const row = db.query(`SELECT MAX(day) as d FROM ${tbl}`).get();
+    if (row?.d && (!latest || row.d > latest))
+      latest = row.d;
+  }
+  return latest;
+}
+function exitCodeForChecks(checks) {
+  const fail = checks.find((c) => c.status === "fail");
+  if (!fail)
+    return 0;
+  if (fail.id === "token" || fail.id === "token-valid")
+    return exitCodeFor(new CliError("TOKEN_MISSING", fail.detail));
+  return exitCodeFor(new CliError("DB_ERROR", fail.detail));
+}
+var doctorCommand = dataCommand({
+  meta: { name: "doctor", description: "Diagnose token, database, and sync health, and suggest the next step." },
+  args: { offline: { type: "boolean", default: false, description: "Skip the live Oura API token-validation call" } },
+  async run(ctx, args) {
+    const deps = {
+      resolveToken: () => resolveToken(args.token),
+      openDb: () => {
+        const db = openDatabase(args.db);
+        ensureSchema(db);
+        return { db, path: getDbPath(args.db) };
+      },
+      createClient: (token) => new OuraClient({ token }),
+      offline: args.offline === true,
+      today: ctx.today
+    };
+    const result = await runChecks(deps);
+    return {
+      json: result,
+      text: () => formatDoctorTable(result),
+      exitCode: exitCodeForChecks(result.checks)
+    };
+  }
+});
+
 // src/commands/manifest.ts
-function manifestCommand(version) {
+var EXAMPLES = {
+  fetch: ["oura-cli fetch sleep", "oura-cli fetch hr --days 7", "oura-cli fetch workout --from 2026-05-01 --to 2026-05-31"],
+  db: ["oura-cli db today", "oura-cli db week --format json"],
+  report: ["oura-cli report --period week"],
+  doctor: ["oura-cli doctor --offline"]
+};
+function buildOpenclawManifest(version, commands) {
+  const m = buildManifest(version, commands);
+  return {
+    id: "oura-cli",
+    version,
+    runtime: "bun",
+    bin: "oura-cli",
+    description: "Oura Ring CLI \u2014 query and analyze Oura Ring health data. Designed for humans and agents.",
+    commands: m.commands.map((c) => ({
+      name: c.name,
+      description: c.description,
+      examples: EXAMPLES[c.name] ?? [`oura-cli ${c.name}`]
+    })),
+    envVars: ["OURA_TOKEN", "OURA_TOKEN_PATH", "OURA_DB_PATH", "OURA_TZ"],
+    healthcheck: { command: "healthcheck", expects: { ok: "boolean", version: "string", latencyMs: "number" } }
+  };
+}
+function manifestCommand(version, getCommands) {
   return defineCommand({
     meta: { name: "manifest", description: "Print openclaw-tool-registry-compatible manifest as JSON." },
     args: {},
     run() {
-      console.log(JSON.stringify({
-        id: "oura-cli",
-        version,
-        runtime: "bun",
-        bin: "oura-cli",
-        description: "Oura Ring CLI \u2014 query and analyze Oura Ring health data. Designed for humans and agents.",
-        commands: [
-          { name: "login", description: "Save an Oura Personal Access Token.", examples: ["oura-cli login"] },
-          { name: "describe", description: "Emit a machine-readable manifest of commands.", examples: ["oura-cli describe"] },
-          { name: "sleep", description: "Fetch daily sleep scores from Oura API.", examples: ["oura-cli sleep --start 2026-05-01"] },
-          { name: "readiness", description: "Fetch daily readiness scores from Oura API.", examples: ["oura-cli readiness --start 2026-05-01"] },
-          { name: "activity", description: "Fetch daily activity scores from Oura API.", examples: ["oura-cli activity --start 2026-05-01"] },
-          { name: "hr", description: "Fetch heart rate samples from Oura API.", examples: ["oura-cli hr --start 2026-05-01"] },
-          { name: "spo2", description: "Fetch blood oxygen (SpO2) data from Oura API.", examples: ["oura-cli spo2 --start 2026-05-01"] },
-          { name: "stress", description: "Fetch daily stress data from Oura API.", examples: ["oura-cli stress --start 2026-05-01"] },
-          { name: "workout", description: "Fetch workout data from Oura API.", examples: ["oura-cli workout --start 2026-05-01"] },
-          { name: "sync", description: "Sync all Oura collections into the local DB.", examples: ["oura-cli sync"] },
-          { name: "db", description: "Query the local SQLite cache.", examples: ["oura-cli db today"] },
-          { name: "report", description: "Render a weekly or monthly summary report.", examples: ["oura-cli report --period week"] },
-          { name: "healthcheck", description: "Quick local DB health probe.", examples: ["oura-cli healthcheck"] },
-          { name: "manifest", description: "Print openclaw-tool-registry-compatible manifest as JSON.", examples: ["oura-cli manifest"] }
-        ],
-        envVars: ["OURA_TOKEN", "OURA_TOKEN_PATH", "OURA_DB_PATH", "OURA_TZ"],
-        healthcheck: { command: "healthcheck", expects: { ok: "boolean", version: "string", latencyMs: "number" } }
-      }, null, 2));
+      console.log(JSON.stringify(buildOpenclawManifest(version, getCommands()), null, 2));
     }
   });
 }
 
-// src/commands/api-command.ts
-function createApiCommand(name, description, endpoint) {
-  return defineCommand({
-    meta: { name, description },
-    subCommands: {
-      today: defineCommand({
-        meta: { name: "today", description: `Today's ${name} data` },
-        args: { ...commonArgs },
-        async run({ args }) {
-          applyNoColor(args);
-          try {
-            const client = getClient({ token: args.token });
-            const day = todayDate(args.tz);
-            const data = await client.fetch(endpoint, day, day);
-            console.log(JSON.stringify(data, null, 2));
-          } catch (err) {
-            handleError(err, args);
-          }
-        }
-      }),
-      date: defineCommand({
-        meta: { name: "date", description: `${name} data for a specific date (YYYY-MM-DD)` },
-        args: {
-          ...commonArgs,
-          day: { type: "positional", required: true, description: "Target date (YYYY-MM-DD)" }
-        },
-        async run({ args }) {
-          applyNoColor(args);
-          try {
-            const client = getClient({ token: args.token });
-            const data = await client.fetch(endpoint, args.day, args.day);
-            console.log(JSON.stringify(data, null, 2));
-          } catch (err) {
-            handleError(err, args);
-          }
-        }
-      }),
-      week: defineCommand({
-        meta: { name: "week", description: `Last 7 days of ${name} data` },
-        args: { ...commonArgs },
-        async run({ args }) {
-          applyNoColor(args);
-          try {
-            const client = getClient({ token: args.token });
-            const { start, end } = dateRange(7, args.tz);
-            const data = await client.fetch(endpoint, start, end);
-            console.log(JSON.stringify(data, null, 2));
-          } catch (err) {
-            handleError(err, args);
-          }
-        }
-      })
-    }
-  });
-}
+// src/commands/fetch.ts
+function resolveRange(opts) {
+  const modes = [opts.day !== undefined, opts.from !== undefined || opts.to !== undefined, opts.days !== undefined].filter(Boolean).length;
+  if (modes > 1)
+    throw new CliError("BAD_ARGS", "Use only one of --day, --from/--to, or --days.");
+  if (opts.day !== undefined) {
+    const d = assertCalendarDate(opts.day, "--day");
+    return { start: d, end: d };
+  }
+  if (opts.from !== undefined || opts.to !== undefined) {
+    if (opts.from === undefined || opts.to === undefined)
+      throw new CliError("BAD_ARGS", "--from and --to must be given together.");
+    const start = assertCalendarDate(opts.from, "--from");
+    const end = assertCalendarDate(opts.to, "--to");
+    if (start > end)
+      throw new CliError("BAD_ARGS", `--from (${start}) must not be after --to (${end}).`);
+    return { start, end };
+  }
+  if (opts.days !== undefined) {
+    const n = assertPositiveInt(opts.days, "--days");
+    return { start: shiftDay(opts.today, -(n - 1)), end: opts.today };
+  }
+  return { start: opts.today, end: opts.today };
+}
+var fetchCommand = dataCommand({
+  meta: { name: "fetch", description: "Fetch raw records for one Oura collection straight from the API (JSON)." },
+  args: {
+    collection: { type: "positional", required: true, description: `Collection: ${names().join(" | ")}` },
+    day: { type: "string", description: "Single day (YYYY-MM-DD). Default: today." },
+    from: { type: "string", description: "Range start (YYYY-MM-DD); requires --to" },
+    to: { type: "string", description: "Range end (YYYY-MM-DD); requires --from" },
+    days: { type: "string", description: "Last N days ending today" }
+  },
+  jsonOnly: true,
+  async run(ctx, args) {
+    const c = byName(args.collection);
+    if (!c)
+      throw new CliError("BAD_ARGS", `Unknown collection "${args.collection}".`, `Valid collections: ${names().join(", ")}`);
+    const { start, end } = resolveRange({
+      day: args.day,
+      from: args.from,
+      to: args.to,
+      days: args.days,
+      today: ctx.today
+    });
+    const client = new OuraClient(args.token ? { token: args.token } : {});
+    const data = await fetchCollection(client, c, start, end, ctx.tz);
+    return { json: data, text: () => JSON.stringify(data, null, 2) };
+  }
+});
 
 // src/lib/argv-normalize.ts
 var GLOBAL_FLAGS_WITH_VALUE = new Set(["--format", "--token", "--db", "--tz"]);
@@ -2583,14 +2819,9 @@ var SUBCOMMANDS = new Set([
   "login",
   "describe",
   "healthcheck",
+  "doctor",
   "manifest",
-  "sleep",
-  "readiness",
-  "activity",
-  "hr",
-  "spo2",
-  "stress",
-  "workout",
+  "fetch",
   "sync",
   "db",
   "report"
@@ -2631,10 +2862,21 @@ function normalizeArgv(argv) {
 }
 
 // src/index.ts
-var VERSION = "0.4.4";
+var VERSION = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf-8")).version;
 if (process.argv.includes("--no-color") || process.env.NO_COLOR) {
   source_default.level = 0;
 }
+var subCommands = {
+  login: loginCommand,
+  describe: describeCommand(VERSION, () => subCommands),
+  healthcheck: healthcheckCommand(VERSION),
+  doctor: doctorCommand,
+  manifest: manifestCommand(VERSION, () => subCommands),
+  fetch: fetchCommand,
+  sync: syncCommand,
+  db: dbCommand,
+  report: reportCommand
+};
 var main = defineCommand({
   meta: {
     name: "oura-cli",
@@ -2642,22 +2884,7 @@ var main = defineCommand({
     description: "Oura Ring CLI \u2014 query and analyze Oura Ring health data. Designed for humans and agents."
   },
   args: { ...commonArgs },
-  subCommands: {
-    login: loginCommand,
-    describe: describeCommand(VERSION),
-    healthcheck: healthcheckCommand(VERSION),
-    manifest: manifestCommand(VERSION),
-    sleep: createApiCommand("sleep", "Fetch daily sleep scores from Oura API.", "daily_sleep"),
-    readiness: createApiCommand("readiness", "Fetch daily readiness scores from Oura API.", "daily_readiness"),
-    activity: createApiCommand("activity", "Fetch daily activity scores from Oura API.", "daily_activity"),
-    hr: createApiCommand("hr", "Fetch heart rate samples from Oura API.", "heartrate"),
-    spo2: createApiCommand("spo2", "Fetch blood oxygen (SpO2) data from Oura API.", "daily_spo2"),
-    stress: createApiCommand("stress", "Fetch daily stress data from Oura API.", "daily_stress"),
-    workout: createApiCommand("workout", "Fetch workout data from Oura API.", "workout"),
-    sync: syncCommand,
-    db: dbCommand,
-    report: reportCommand
-  }
+  subCommands
 });
 var normalized = normalizeArgv(process.argv);
 runMain(main, { rawArgs: normalized.slice(2) });