qotm 1.0.7 → 2.0.0

package/dist/cli.js

@@ -0,0 +1,1960 @@
+#!/usr/bin/env node
+
+// src/io.ts
+import { spawn } from "node:child_process";
+var processIo = () => ({
+  stdout: (text) => void process.stdout.write(text),
+  stderr: (text) => void process.stderr.write(text),
+  env: process.env,
+  isTTY: Boolean(process.stdout.isTTY),
+  columns: process.stdout.columns,
+  openUrl: openInBrowser
+});
+function openInBrowser(url2) {
+  const [cmd, args] = process.env.BROWSER ? [process.env.BROWSER, [url2]] : process.platform === "darwin" ? ["open", [url2]] : process.platform === "win32" ? ["cmd", ["/c", "start", '""', url2.replace(/&/g, "^&")]] : ["xdg-open", [url2]];
+  return new Promise((resolve2, reject) => {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", reject);
+    child.on("spawn", () => {
+      child.unref();
+      resolve2();
+    });
+  });
+}
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+  exitCode;
+};
+
+// src/args.ts
+import { parseArgs } from "node:util";
+function parse(args, options, allowPositionals = false) {
+  try {
+    return parseArgs({ args, options, allowPositionals, strict: true });
+  } catch (err) {
+    throw new CliError(`${err.message.replace(/\. To specify.*$/s, "")}. Run qotm --help.`, 2);
+  }
+}
+
+// src/dataset.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DatabaseSync } from "node:sqlite";
+var SCHEMA_VERSION = 1;
+var TABLES = ["authors", "meta", "quote_topics", "quotes", "quotes_fts", "topics"];
+var SNAPSHOT = fileURLToPath(new URL("../data/qotm.sqlite", import.meta.url));
+var SNAPSHOT_MANIFEST = fileURLToPath(new URL("../data/snapshot.json", import.meta.url));
+var toQuote = (r) => ({
+  n: Number(r.n),
+  id: String(r.id),
+  text: String(r.text),
+  type: r.type,
+  author: r.author ?? null,
+  authorSlug: r.author_slug ?? null,
+  work: r.work ?? null,
+  year: r.year == null ? null : Number(r.year),
+  source: r.source ?? null,
+  sourceUrl: r.source_url ?? null,
+  contributor: r.contributor ?? null
+});
+var DatasetError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+  }
+  reason;
+};
+var Dataset = class _Dataset {
+  constructor(db, file, meta) {
+    this.db = db;
+    this.file = file;
+    this.meta = meta;
+  }
+  db;
+  file;
+  meta;
+  /** Opens and checks a file: a known schema version and every table it should have. */
+  static open(file) {
+    if (!existsSync(file)) throw new DatasetError(`${file} does not exist`, "missing");
+    let db;
+    try {
+      db = new DatabaseSync(file, { readOnly: true });
+    } catch (err) {
+      throw new DatasetError(`${file} cannot be opened: ${err.message}`, "corrupt");
+    }
+    try {
+      const userVersion = Number(db.prepare("PRAGMA user_version").get().user_version);
+      const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table'`).all().map(
+        (r) => String(r.name)
+      );
+      const meta = Object.fromEntries(
+        db.prepare("SELECT key, value FROM meta").all().map((r) => [String(r.key), String(r.value)])
+      );
+      const schemaVersion = Number(meta.schemaVersion ?? userVersion);
+      if (schemaVersion !== SCHEMA_VERSION || userVersion !== SCHEMA_VERSION)
+        throw new DatasetError(
+          `${file} is dataset schema ${schemaVersion}; this qotm reads schema ${SCHEMA_VERSION}`,
+          "schema"
+        );
+      const missing = TABLES.filter((t) => !tables.includes(t));
+      if (missing.length) throw new DatasetError(`${file} has no ${missing.join(", ")} table`, "corrupt");
+      db.prepare("SELECT count(*) FROM quotes").get();
+      return new _Dataset(db, file, {
+        version: meta.version ?? "unknown",
+        schemaVersion,
+        builtAt: meta.builtAt ?? null
+      });
+    } catch (err) {
+      db.close();
+      if (err instanceof DatasetError) throw err;
+      throw new DatasetError(`${file} is not a qotm dataset: ${err.message}`, "corrupt");
+    }
+  }
+  count() {
+    return Number(this.db.prepare("SELECT count(*) AS n FROM quotes").get().n);
+  }
+  /** The ids `qotm` may draw from: every quote, or those under a topic, by an author, or in a set. */
+  candidates(filter = {}) {
+    const where = [];
+    const params = [];
+    if (filter.topic) {
+      where.push(
+        "id IN (SELECT qt.quote_id FROM quote_topics qt JOIN topics t ON t.id = qt.topic_id WHERE t.slug = ?)"
+      );
+      params.push(filter.topic);
+    }
+    if (filter.author) {
+      where.push("author_slug = ?");
+      params.push(filter.author);
+    }
+    if (filter.ids) {
+      if (!filter.ids.length) return [];
+      where.push(`id IN (${filter.ids.map(() => "?").join(", ")})`);
+      params.push(...filter.ids);
+    }
+    const sql = `SELECT id FROM quotes${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY n`;
+    return this.db.prepare(sql).all(...params).map((r) => String(r.id));
+  }
+  quote(id) {
+    const row = this.db.prepare("SELECT * FROM quotes WHERE id = ?").get(id);
+    return row ? toQuote(row) : null;
+  }
+  /** A quote's topic slugs. */
+  topicsOf(id) {
+    return this.db.prepare(
+      "SELECT t.slug FROM quote_topics qt JOIN topics t ON t.id = qt.topic_id WHERE qt.quote_id = ? ORDER BY t.slug"
+    ).all(id).map((r) => String(r.slug));
+  }
+  topics() {
+    return this.db.prepare("SELECT slug FROM topics ORDER BY slug").all().map((r) => String(r.slug));
+  }
+  authors() {
+    return this.db.prepare("SELECT slug FROM authors ORDER BY slug").all().map((r) => String(r.slug));
+  }
+  /**
+   * Full-text search (FTS5 over text, author and work), best match first.
+   * Each word is matched as typed or as a prefix, all words required.
+   */
+  search(text, limit = 10) {
+    const words = text.match(/[\p{L}\p{N}]+/gu) ?? [];
+    if (!words.length) return [];
+    const match = words.map((w) => `"${w.replace(/"/g, "")}"*`).join(" ");
+    try {
+      return this.db.prepare(
+        "SELECT q.* FROM quotes_fts f JOIN quotes q ON q.n = f.rowid WHERE quotes_fts MATCH ? ORDER BY rank LIMIT ?"
+      ).all(match, limit).map(toQuote);
+    } catch (error) {
+      if (error instanceof Error && /no such module: fts5/.test(error.message)) {
+        throw new CliError(
+          `qotm search needs Node.js 22.16+ or 24+ (this is ${process.version}). Everything else works; update Node to search, or use qotm search --web.`
+        );
+      }
+      throw error;
+    }
+  }
+  close() {
+    this.db.close();
+  }
+};
+function openDataset(dataDir, snapshot = SNAPSHOT) {
+  const local = join(dataDir, "qotm.sqlite");
+  let warning;
+  try {
+    return { dataset: Dataset.open(local), from: "local" };
+  } catch (err) {
+    if (!(err instanceof DatasetError)) throw err;
+    if (err.reason === "schema")
+      warning = `${err.message}. Using the bundled quotes; update qotm (npm i -g qotm) to read it.`;
+    else if (err.reason === "corrupt")
+      warning = `the synced dataset is unreadable (${err.message}). Using the bundled quotes; run qotm sync to fetch it again.`;
+  }
+  return { dataset: Dataset.open(snapshot), from: "snapshot", warning };
+}
+
+// src/config.ts
+import { join as join4 } from "node:path";
+
+// src/paths.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+function qotmPaths(env = process.env, platform = process.platform, home = homedir()) {
+  if (env.QOTM_HOME) return { config: join2(env.QOTM_HOME, "config"), data: join2(env.QOTM_HOME, "data") };
+  if (platform === "darwin")
+    return {
+      config: join2(home, "Library", "Preferences", "qotm"),
+      data: join2(home, "Library", "Application Support", "qotm")
+    };
+  if (platform === "win32") {
+    const roaming = env.APPDATA || join2(home, "AppData", "Roaming");
+    const local = env.LOCALAPPDATA || join2(home, "AppData", "Local");
+    return { config: join2(roaming, "qotm", "Config"), data: join2(local, "qotm", "Data") };
+  }
+  return {
+    config: join2(env.XDG_CONFIG_HOME || join2(home, ".config"), "qotm"),
+    data: join2(env.XDG_DATA_HOME || join2(home, ".local", "share"), "qotm")
+  };
+}
+
+// src/render.ts
+var STYLES = ["pull", "bubble", "card", "slab"];
+var MIN_COLUMNS = 40;
+var sgr = (open2, close) => (s) => s ? `\x1B[${open2}m${s}\x1B[${close}m` : s;
+var none = (s) => s;
+function palette(color) {
+  if (!color)
+    return {
+      text: none,
+      frame: none,
+      credit: none,
+      accent: none,
+      panel: none,
+      panelText: none,
+      panelAccent: none,
+      panelCredit: none
+    };
+  const panel = "48;5;235";
+  return {
+    text: sgr("1", "22"),
+    frame: sgr("38;5;242", "39"),
+    credit: sgr("38;5;248", "39"),
+    accent: sgr("38;5;173", "39"),
+    panel: sgr(panel, "49"),
+    panelText: sgr(`1;38;5;255;${panel}`, "22;39;49"),
+    panelAccent: sgr(`38;5;173;${panel}`, "39;49"),
+    panelCredit: sgr(`38;5;248;${panel}`, "39;49")
+  };
+}
+var cells = (s) => [...s].length;
+function wrapWords(text, width) {
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    let line = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      if (line && cells(line) + 1 + cells(word) > width) {
+        lines.push(line);
+        line = word;
+      } else line = line ? `${line} ${word}` : word;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function balance(text, max) {
+  const count = wrapWords(text, max).length;
+  if (count === 1) return wrapWords(text, max);
+  let width = max;
+  while (width > 12 && wrapWords(text, width - 1).length === count) width--;
+  return wrapWords(text, width);
+}
+var longest = (lines) => Math.max(0, ...lines.map(cells));
+var clip = (s, n2) => cells(s) > n2 ? `${[...s].slice(0, n2 - 1).join("")}\u2026` : s;
+function pull(card2, columns, p) {
+  const indent = "         ";
+  const lines = balance(card2.text, Math.min(60, columns - indent.length - 2));
+  const marks = ["  \u2584\u2584 \u2584\u2584  ", "  \u2580\u2588 \u2580\u2588  "];
+  const out = lines.map((l, i) => (i < 2 ? p.accent(marks[i]) : indent) + p.text(l));
+  if (lines.length < 2) out.push(p.accent(marks[1]));
+  out.push("");
+  const ref = card2.ref ? p.frame(`  \xB7  ${card2.ref}`) : "";
+  out.push(`${indent}${p.accent("\u2014")}  ${p.credit(card2.credit)}${ref}`);
+  if (card2.source)
+    out.push(...balance(card2.source, Math.min(60, columns - indent.length - 2)).map((l) => indent + p.frame(l)));
+  return out;
+}
+var Q = ["      \u2584\u2584\u2584\u2584\u2584", "    \u2584\u2580     \u2580\u2584", "    \u2588       \u2588", "    \u2580\u2584     \u2584\u2588", "      \u2580\u2580\u2580\u2580\u2580 \u2588", "            \u2580\u2584\u2584"];
+function bubble(card2, columns, p) {
+  const max = Math.min(56, columns - 12);
+  const lines = balance(card2.text, max);
+  const credit2 = `\u2014 ${clip(card2.credit, max - 2)}`;
+  const source = card2.source ? balance(card2.source, max) : [];
+  const width = Math.max(longest(lines), cells(credit2), longest(source));
+  const inner = width + 6;
+  const row = (content, length) => `  ${p.frame("\u2502")}   ${content}${" ".repeat(width - length)}   ${p.frame("\u2502")}`;
+  const blank = `  ${p.frame(`\u2502${" ".repeat(inner)}\u2502`)}`;
+  return [
+    `  ${p.frame(`\u256D${"\u2500".repeat(inner)}\u256E`)}`,
+    blank,
+    ...lines.map((l) => row(p.text(l), cells(l))),
+    blank,
+    row(" ".repeat(width - cells(credit2)) + p.accent("\u2014") + " " + p.credit(credit2.slice(2)), width),
+    ...source.map((l) => row(" ".repeat(width - cells(l)) + p.frame(l), width)),
+    blank,
+    `  ${p.frame(`\u2570\u2500\u2500\u252C${"\u2500".repeat(inner - 3)}\u256F`)}`,
+    `     ${p.frame("\u2502")}`,
+    ...Q.map((l) => p.accent(l))
+  ];
+}
+function card(c, columns, p) {
+  const max = Math.min(50, columns - 14);
+  const lines = balance(c.text, max);
+  const credit2 = clip(c.credit, max);
+  const source = c.source ? balance(c.source, max) : [];
+  const inner = Math.max(longest(lines), cells(credit2), longest(source), 24) + 10;
+  const centre = (s, paint) => {
+    const left = Math.floor((inner - cells(s)) / 2);
+    return `  ${p.frame("\u2502")}${" ".repeat(left)}${paint(s)}${" ".repeat(inner - left - cells(s))}${p.frame("\u2502")}`;
+  };
+  const blank = `  ${p.frame(`\u2502${" ".repeat(inner)}\u2502`)}`;
+  const ref = c.ref ?? "";
+  const status2 = c.status;
+  const dashes = inner - 5 - cells(ref) - cells(status2) - (ref ? 1 : 0);
+  const bottom = dashes >= 2 ? `  ${p.frame("\u2570\u2500")}${ref ? ` ${p.credit(ref)}` : ""} ${p.frame("\u2500".repeat(dashes))} ${p.accent(status2)} ${p.frame("\u2500\u256F")}` : `  ${p.frame(`\u2570${"\u2500".repeat(inner)}\u256F`)}`;
+  return [
+    `  ${p.frame(`\u256D${"\u2500".repeat(inner)}\u256E`)}`,
+    blank,
+    ...lines.map((l) => centre(l, p.text)),
+    blank,
+    centre("\u2500\u2500", p.accent),
+    centre(credit2, p.credit),
+    ...source.map((l) => centre(l, p.frame)),
+    blank,
+    bottom
+  ];
+}
+function slab(c, columns, p) {
+  const max = Math.min(56, columns - 11);
+  const lines = balance(c.text, max);
+  const credit2 = `\u2014 ${clip(c.credit, max - 2)}`;
+  const source = c.source ? balance(c.source, max) : [];
+  const width = Math.max(longest(lines), cells(credit2), longest(source)) + 6;
+  const edge = `  ${p.accent("\u258C")}`;
+  const blank = edge + p.panel(" ".repeat(width));
+  const row = (content, length, rest = p.panel) => `${edge}${p.panel("   ")}${content}${rest(" ".repeat(width - 3 - length))}`;
+  const footer = clip([...c.topics, c.status, c.ref].filter(Boolean).join(" \xB7 "), columns - 5);
+  return [
+    blank,
+    ...lines.map((l) => row(p.panelText(l), cells(l))),
+    blank,
+    row(p.panelAccent("\u2014") + p.panel(" ") + p.panelCredit(credit2.slice(2)), cells(credit2)),
+    ...source.map((l) => row(p.panelCredit(l), cells(l))),
+    blank,
+    `    ${p.frame(footer)}`
+  ];
+}
+var DRAW = { pull, bubble, card, slab };
+function render(c, style2, columns, color) {
+  return `
+${DRAW[style2](c, columns, palette(color)).join("\n")}
+`;
+}
+
+// src/store.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { dirname, join as join3 } from "node:path";
+function readJson(file, empty) {
+  try {
+    return { ...empty, ...JSON.parse(readFileSync(file, "utf8")) };
+  } catch {
+    return empty;
+  }
+}
+function writeJson(file, value) {
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, "	")}
+`);
+  renameSync(tmp, file);
+}
+var HISTORY_SIZE = 50;
+var historyFile = (data) => join3(data, "history.json");
+var readHistory = (data) => readJson(historyFile(data), { shown: [] });
+function remember(data, id, now = /* @__PURE__ */ new Date(), size = HISTORY_SIZE) {
+  const { shown } = readHistory(data);
+  writeJson(historyFile(data), {
+    shown: [{ id, at: now.toISOString() }, ...shown.filter((s) => s.id !== id)].slice(0, Math.max(1, size))
+  });
+}
+var favoritesFile = (data) => join3(data, "favorites.json");
+var readFavorites = (data) => {
+  const f = readJson(favoritesFile(data), {});
+  return {
+    favorites: f.favorites ?? [],
+    pending: { add: f.pending?.add ?? [], remove: f.pending?.remove ?? [] },
+    localOnly: f.localOnly ?? []
+  };
+};
+var writeFavorites = (data, f) => writeJson(favoritesFile(data), f);
+function addFavorite(data, id, now = /* @__PURE__ */ new Date()) {
+  const f = readFavorites(data);
+  if (f.favorites.some((x) => x.id === id)) return false;
+  writeFavorites(data, {
+    favorites: [{ id, addedAt: now.toISOString() }, ...f.favorites],
+    pending: { add: [.../* @__PURE__ */ new Set([...f.pending.add, id])], remove: f.pending.remove.filter((x) => x !== id) },
+    localOnly: f.localOnly
+  });
+  return true;
+}
+function removeFavorite(data, id) {
+  const f = readFavorites(data);
+  if (!f.favorites.some((x) => x.id === id)) return false;
+  writeFavorites(data, {
+    favorites: f.favorites.filter((x) => x.id !== id),
+    pending: { add: f.pending.add.filter((x) => x !== id), remove: [.../* @__PURE__ */ new Set([...f.pending.remove, id])] },
+    localOnly: f.localOnly.filter((x) => x !== id)
+  });
+  return true;
+}
+var personalFile = (data) => join3(data, "personal.json");
+var readPersonal = (data) => readJson(personalFile(data), { quotes: [] });
+function addPersonal(data, quote2, now = /* @__PURE__ */ new Date()) {
+  const { quotes } = readPersonal(data);
+  let id;
+  do
+    id = `p_${randomBytes(6).toString("base64url").toLowerCase().replace(/[^a-z0-9]/g, "").slice(0, 8).padEnd(8, "0")}`;
+  while (quotes.some((q) => q.id === id));
+  const created = {
+    id,
+    text: quote2.text,
+    author: quote2.author ?? null,
+    work: quote2.work ?? null,
+    year: quote2.year ?? null,
+    createdAt: now.toISOString()
+  };
+  writeJson(personalFile(data), { quotes: [...quotes, created] });
+  return created;
+}
+function setRemoteId(data, id, remoteId) {
+  const { quotes } = readPersonal(data);
+  writeJson(personalFile(data), { quotes: quotes.map((q) => q.id === id ? { ...q, remoteId } : q) });
+}
+
+// src/config.ts
+var SETTINGS = {
+  api: {
+    default: "https://api.qotm.dev",
+    env: "QOTM_API_URL",
+    describe: "the qotm API (login, sync, favorites, submit)",
+    parse: (v) => url(v)
+  },
+  site: {
+    default: "https://qotm.dev",
+    env: "QOTM_SITE_URL",
+    describe: "the qotm site (qotm open, search --web)",
+    parse: (v) => url(v)
+  },
+  color: {
+    default: "auto",
+    env: void 0,
+    describe: "auto (on a terminal), always or never",
+    parse: (v) => {
+      if (!["auto", "always", "never"].includes(v)) throw new CliError("color is auto, always or never.", 2);
+      return v;
+    }
+  },
+  style: {
+    default: "pull",
+    env: void 0,
+    describe: "how a quote is drawn: pull, bubble, card or slab",
+    parse: (v) => {
+      if (!STYLES.includes(v))
+        throw new CliError(`style is ${STYLES.slice(0, -1).join(", ")} or ${STYLES.at(-1)}.`, 2);
+      return v;
+    }
+  },
+  history: {
+    default: "50",
+    env: void 0,
+    describe: "how many recent quotes qotm avoids repeating (0: none)",
+    parse: (v) => {
+      if (!/^\d{1,4}$/.test(v)) throw new CliError("history is a number of quotes, like 50.", 2);
+      return String(Number(v));
+    }
+  }
+};
+var KEYS = Object.keys(SETTINGS);
+function url(v) {
+  try {
+    const u = new URL(v);
+    if (u.protocol !== "https:" && u.protocol !== "http:") throw new Error();
+    return v.replace(/\/+$/, "");
+  } catch {
+    throw new CliError(`"${v}" is not a URL (https://\u2026).`, 2);
+  }
+}
+var settingsFile = (io) => join4(qotmPaths(io.env).config, "settings.json");
+var readSettings = (io) => readJson(settingsFile(io), {});
+function resolve(io, key) {
+  const s = SETTINGS[key];
+  const fromEnv = s.env ? io.env[s.env] : void 0;
+  if (fromEnv) return { key, value: s.parse(fromEnv), from: "env" };
+  const saved = readSettings(io)[key];
+  if (saved !== void 0) return { key, value: saved, from: "settings" };
+  return { key, value: s.default, from: "default" };
+}
+var setting = (io, key) => resolve(io, key).value;
+function setSetting(io, key, value) {
+  const parsed = SETTINGS[key].parse(value);
+  writeJson(settingsFile(io), { ...readSettings(io), [key]: parsed });
+  return parsed;
+}
+function unsetSetting(io, key) {
+  const { [key]: _, ...rest } = readSettings(io);
+  writeJson(settingsFile(io), rest);
+}
+function assertKey(key) {
+  if (!key || !(key in SETTINGS))
+    throw new CliError(`Unknown setting "${key ?? ""}". Settings: ${KEYS.join(", ")}.`, 2);
+  return key;
+}
+
+// src/version.ts
+var VERSION = "2.0.0";
+
+// src/http.ts
+async function api(io, path, init = {}) {
+  const base = setting(io, "api");
+  let res;
+  try {
+    res = await fetch(`${base}${path}`, {
+      method: init.method ?? "GET",
+      headers: {
+        "user-agent": `qotm/${VERSION}`,
+        accept: "application/json",
+        ...init.body !== void 0 ? { "content-type": "application/json" } : {},
+        ...init.token ? { authorization: `Bearer ${init.token}` } : {},
+        ...init.headers
+      },
+      body: init.body !== void 0 ? JSON.stringify(init.body) : void 0,
+      signal: AbortSignal.timeout(init.timeoutMs ?? 15e3)
+    });
+  } catch (err) {
+    const cause = String(err.cause ?? "");
+    if (/bad port/i.test(cause))
+      throw new CliError(
+        `${base}: fetch refuses that port (a "bad port" in the Fetch standard); use another, or the https address.`
+      );
+    const why = err.name === "TimeoutError" ? "it did not answer in time" : "it could not be reached";
+    throw new CliError(`${base}: ${why}. Check your connection, or qotm config get api.`);
+  }
+  const text = await res.text();
+  let body2 = text;
+  try {
+    body2 = text ? JSON.parse(text) : null;
+  } catch {
+  }
+  return { status: res.status, headers: res.headers, body: body2 };
+}
+function apiMessage(res) {
+  const m = res.body?.message;
+  return typeof m === "string" ? m : Array.isArray(m) ? m.join("; ") : `HTTP ${res.status}`;
+}
+
+// src/state.ts
+import { chmodSync, rmSync } from "node:fs";
+import { join as join5 } from "node:path";
+var sessionFile = (config2) => join5(config2, "session.json");
+var readSession = (config2) => {
+  const s = readJson(sessionFile(config2), {});
+  return s.token ? s : null;
+};
+function writeSession(config2, session) {
+  writeJson(sessionFile(config2), session);
+  try {
+    chmodSync(sessionFile(config2), 384);
+  } catch {
+  }
+}
+var clearSession = (config2) => rmSync(sessionFile(config2), { force: true });
+var syncFile = (data) => join5(data, "sync.json");
+var readSync = (data) => {
+  const s = readJson(syncFile(data), {});
+  return s.version ? s : null;
+};
+function writeSync(data, state) {
+  writeJson(syncFile(data), state);
+}
+
+// src/favorites-sync.ts
+async function syncFavorites(io, timeoutMs = 15e3) {
+  const { config: config2, data } = qotmPaths(io.env);
+  const session = readSession(config2);
+  if (!session) return { status: "signed-out" };
+  const before = readFavorites(data);
+  const sent = { add: [...before.pending.add], remove: [...before.pending.remove] };
+  let res;
+  try {
+    res = await api(io, "/v1/me/favorites/sync", {
+      method: "PUT",
+      token: session.token,
+      body: sent,
+      timeoutMs
+    });
+  } catch {
+    return { status: "queued", reason: "the API could not be reached", pending: sent.add.length + sent.remove.length };
+  }
+  if (res.status === 401)
+    return {
+      status: "queued",
+      reason: "your session ended; run qotm login",
+      pending: sent.add.length + sent.remove.length
+    };
+  if (res.status !== 200)
+    return { status: "queued", reason: apiMessage(res), pending: sent.add.length + sent.remove.length };
+  const now = readFavorites(data);
+  const pending = {
+    add: now.pending.add.filter((id) => !sent.add.includes(id)),
+    remove: now.pending.remove.filter((id) => !sent.remove.includes(id))
+  };
+  const skipped = res.body.skipped ?? [];
+  const localOnly = [.../* @__PURE__ */ new Set([...now.localOnly, ...skipped])].filter((id) => !pending.remove.includes(id));
+  const merged = res.body.favorites.filter((f) => !pending.remove.includes(f.id));
+  const known = new Set(merged.map((f) => f.id));
+  const keep = now.favorites.filter(
+    (f) => !known.has(f.id) && (localOnly.includes(f.id) || pending.add.includes(f.id))
+  );
+  const favorites2 = [...keep, ...merged].sort((a, b) => b.addedAt.localeCompare(a.addedAt));
+  writeFavorites(data, { favorites: favorites2, pending, localOnly });
+  return { status: "synced", handle: session.handle, count: favorites2.length, skipped };
+}
+
+// src/output.ts
+var siteUrl = (io) => setting(io, "site");
+var quoteUrl = (io, id) => id.startsWith("q_") ? `${siteUrl(io)}/q/${id.slice(2)}` : null;
+function useColor(io, plain = false) {
+  if (plain) return false;
+  const configured = setting(io, "color");
+  if (configured !== "auto") return configured === "always";
+  if (io.env.FORCE_COLOR && io.env.FORCE_COLOR !== "0") return true;
+  if ("NO_COLOR" in io.env && io.env.NO_COLOR !== void 0) return false;
+  if (io.env.TERM === "dumb") return false;
+  return io.isTTY;
+}
+var sgr2 = (open2, close) => (on) => (s) => on ? `\x1B[${open2}m${s}\x1B[${close}m` : s;
+var style = {
+  bold: sgr2("1", "22"),
+  /** The kit's clay accent (#b85c3e), as near as 256 colours get. */
+  clay: sgr2("38;5;173", "39"),
+  /** Muted text. */
+  muted: sgr2("38;5;245", "39")
+};
+function wrap(text, width) {
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    let line = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      if (line && line.length + 1 + word.length > width) {
+        lines.push(line);
+        line = word;
+      } else line = line ? `${line} ${word}` : word;
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/local.ts
+var QUOTE_ID = /^q_[a-z0-9]{3,32}$/i;
+function target(given, data, verb) {
+  if (given) {
+    const id = given.startsWith("q_") ? given : `q_${given}`;
+    if (!QUOTE_ID.test(id)) throw new CliError(`"${given}" is not a quote id (q_8f2k1c).`, 2);
+    return id;
+  }
+  const [latest] = readHistory(data).shown;
+  if (!latest) throw new CliError(`Nothing to ${verb} yet. Run qotm for a quote, then qotm ${verb}.`);
+  if (latest.id.startsWith("p_"))
+    throw new CliError("The last quote is one of your private quotes; favorites are quotes from the dataset.");
+  return latest.id;
+}
+async function share(io) {
+  const r = await syncFavorites(io, 3e3);
+  return r.status === "queued" ? ` (it syncs with your account later: ${r.reason})` : "";
+}
+var save = {
+  name: "save",
+  usage: "qotm save [<id>]",
+  summary: "add the last quote to your favorites",
+  help: "Favorites live on this machine; signed in, they are shared with your account (offline, at the next qotm sync).",
+  async run(args, io) {
+    const { positionals } = parse(args, {}, true);
+    const { data } = qotmPaths(io.env);
+    const id = target(positionals[0], data, "save");
+    const muted = style.muted(useColor(io));
+    const added = addFavorite(data, id);
+    const note = added ? await share(io) : "";
+    io.stdout(muted(added ? `saved to favorites${note}
+` : "already in your favorites\n"));
+    return 0;
+  }
+};
+var unsave = {
+  name: "unsave",
+  usage: "qotm unsave [<id>]",
+  summary: "remove the last quote (or <id>) from your favorites",
+  async run(args, io) {
+    const { positionals } = parse(args, {}, true);
+    const { data } = qotmPaths(io.env);
+    const id = target(positionals[0], data, "unsave");
+    const muted = style.muted(useColor(io));
+    const removed = removeFavorite(data, id);
+    const note = removed ? await share(io) : "";
+    io.stdout(muted(removed ? `removed from favorites${note}
+` : "not in your favorites\n"));
+    return 0;
+  }
+};
+var favorites = {
+  name: "favorites",
+  usage: "qotm favorites [--plain | --json]",
+  summary: "list your favorites",
+  run(args, io) {
+    const { values: v } = parse(args, { plain: { type: "boolean" }, json: { type: "boolean" } });
+    const { data } = qotmPaths(io.env);
+    const list = readFavorites(data).favorites;
+    const { dataset } = openDataset(data);
+    try {
+      const rows = list.map((f) => ({ ...f, quote: dataset.quote(f.id) }));
+      if (v.json) {
+        io.stdout(
+          `${JSON.stringify(
+            rows.map((r) => ({
+              id: r.id,
+              addedAt: r.addedAt,
+              text: r.quote?.text ?? null,
+              author: r.quote?.author ?? null
+            }))
+          )}
+`
+        );
+        return 0;
+      }
+      if (!rows.length) {
+        io.stdout("No favorites yet. Save the last quote with qotm save.\n");
+        return 0;
+      }
+      const color = useColor(io, v.plain);
+      const width = v.plain || !io.columns ? Infinity : io.columns;
+      for (const r of rows) {
+        const words = r.quote ? `${r.quote.text} \u2014 ${r.quote.author ?? (r.quote.contributor ? `@${r.quote.contributor}` : "a former member")}` : "not in this dataset (run qotm sync)";
+        const line = `${r.id}  ${words}`;
+        const clipped = line.length > width ? `${line.slice(0, Math.max(10, width - 1))}\u2026` : line;
+        io.stdout(`${style.muted(color)(clipped.slice(0, r.id.length))}${clipped.slice(r.id.length)}
+`);
+      }
+      return 0;
+    } finally {
+      dataset.close();
+    }
+  }
+};
+var add = {
+  name: "add",
+  usage: 'qotm add "<text>" [--author <name>] [--work <title>] [--year <yyyy>]',
+  summary: "keep a private quote",
+  help: `
+Private quotes never enter the dataset. Signed in, they are also kept in
+your account (My quotes on qotm.dev). qotm --personal draws from them;
+qotm submit <p_id> sends one for review as your original.
+`,
+  async run(args, io) {
+    const { values: v, positionals } = parse(
+      args,
+      { author: { type: "string" }, work: { type: "string" }, year: { type: "string" } },
+      true
+    );
+    const text = positionals.join(" ").replace(/\s+/g, " ").trim();
+    if (!text) throw new CliError('Give the quote: qotm add "Make it work, make it right, make it fast."', 2);
+    if (text.length > 280) throw new CliError(`That is ${text.length} characters; a quote is at most 280.`, 2);
+    if (v.year !== void 0 && !/^\d{1,4}$/.test(v.year)) throw new CliError("--year is a year, like 1974.", 2);
+    const { data } = qotmPaths(io.env);
+    const kept = addPersonal(data, {
+      text,
+      author: v.author?.trim() || null,
+      work: v.work?.trim() || null,
+      year: v.year ? Number(v.year) : null
+    });
+    const muted = style.muted(useColor(io));
+    io.stdout(muted(`kept as a private quote (${kept.id}). qotm --personal shows your private quotes.
+`));
+    const session = readSession(qotmPaths(io.env).config);
+    if (session) {
+      try {
+        const res = await api(io, "/v1/submissions", {
+          method: "POST",
+          token: session.token,
+          timeoutMs: 5e3,
+          body: {
+            type: "private",
+            text,
+            ...kept.author ? { attribution: kept.author } : {},
+            ...kept.work ? { source: kept.work } : {},
+            ...kept.year ? { year: kept.year } : {}
+          }
+        });
+        if (res.status === 200 || res.status === 201) {
+          setRemoteId(data, kept.id, res.body.id);
+          io.stdout(muted(`and in your account's private quotes (${res.body.id})
+`));
+        } else io.stdout(muted(`not sent to your account: ${apiMessage(res)}
+`));
+      } catch {
+        io.stdout(muted("not sent to your account: the API could not be reached\n"));
+      }
+    }
+    return 0;
+  }
+};
+
+// src/commands/login.ts
+import { hostname } from "node:os";
+var CLIENT_ID = "qotm-cli";
+var GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+function deviceLabel(env, host = hostname()) {
+  const base = (p) => p.split(/[\\/]/).pop().replace(/\.exe$/i, "");
+  const shellPath = env.SHELL || env.ComSpec || env.COMSPEC;
+  const shell = shellPath ? base(shellPath) : "terminal";
+  const name = host.replace(/\.local$/, "") || "this computer";
+  return `${name} \xB7 ${shell}`.slice(0, 80);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function heldVersion(io) {
+  try {
+    const { dataset } = openDataset(qotmPaths(io.env).data);
+    const v = dataset.meta.version;
+    dataset.close();
+    return /^v\d{4}\.\d{2}\.\d+$/.test(v) ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var login = {
+  name: "login",
+  usage: "qotm login [--no-browser] [--force]",
+  summary: "sign in to sync favorites and submit quotes",
+  help: `
+Prints a code and opens qotm.dev/device in your browser; approve it there
+and this terminal is signed in. It is listed under Settings \u203A Terminals.
+
+  --no-browser   only print the address (for a remote shell)
+  --force        sign in again, replacing the current session
+`,
+  async run(args, io) {
+    const { values: v } = parse(args, { "no-browser": { type: "boolean" }, force: { type: "boolean" } });
+    const { config: config2 } = qotmPaths(io.env);
+    const current = readSession(config2);
+    if (current && !v.force)
+      throw new CliError(`Already signed in as @${current.handle ?? "?"}. qotm logout first, or qotm login --force.`);
+    const color = useColor(io);
+    const muted = style.muted(color);
+    const start = await api(io, "/auth/device/code", {
+      method: "POST",
+      body: { client_id: CLIENT_ID }
+    });
+    if (start.status !== 200) throw new CliError(`Sign-in could not start: ${apiMessage(start)}.`);
+    const code2 = start.body;
+    const where = code2.verification_uri_complete ?? code2.verification_uri;
+    io.stdout(`To sign in, open ${code2.verification_uri} and enter:
+
+    ${style.bold(color)(code2.user_code)}
+
+`);
+    if (!v["no-browser"] && io.openUrl) {
+      try {
+        await io.openUrl(where);
+        io.stdout(muted("opened in your browser; waiting for you to approve\u2026\n"));
+      } catch {
+        io.stdout(muted(`could not open a browser; go to ${where}
+`));
+      }
+    } else io.stdout(muted("waiting for you to approve\u2026\n"));
+    let interval = Math.max(0, code2.interval) * 1e3;
+    const deadline = Date.now() + code2.expires_in * 1e3;
+    let token = null;
+    while (!token) {
+      if (Date.now() > deadline) throw new CliError("The code expired before it was approved. Run qotm login again.");
+      await sleep(interval);
+      const res = await api(
+        io,
+        "/auth/device/token",
+        {
+          method: "POST",
+          body: { grant_type: GRANT, device_code: code2.device_code, client_id: CLIENT_ID }
+        }
+      );
+      if (res.status === 200 && res.body.access_token) token = res.body.access_token;
+      else if (res.body?.error === "authorization_pending") continue;
+      else if (res.body?.error === "slow_down") interval += 5e3;
+      else if (res.body?.error === "expired_token")
+        throw new CliError("The code expired before it was approved (codes last 15 minutes). Run qotm login again.");
+      else if (res.body?.error === "access_denied")
+        throw new CliError("Sign-in was denied in the browser. Nothing changed here.");
+      else throw new CliError(`Sign-in failed: ${res.body?.error_description ?? res.body?.error ?? apiMessage(res)}.`);
+    }
+    const me = await api(io, "/v1/me", { token });
+    if (me.status !== 200) throw new CliError(`Signed in, but the account could not be read: ${apiMessage(me)}.`);
+    const dataset = heldVersion(io);
+    const device = await api(io, "/v1/me/devices", {
+      method: "POST",
+      token,
+      body: { label: deviceLabel(io.env) },
+      headers: dataset ? { "x-qotm-dataset": dataset } : {}
+    });
+    if (device.status !== 200 && device.status !== 201)
+      throw new CliError(`Signed in, but this terminal could not be registered: ${apiMessage(device)}.`);
+    writeSession(config2, {
+      token,
+      handle: me.body.handle ?? null,
+      deviceId: device.body.id ?? null,
+      api: setting(io, "api"),
+      signedInAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    io.stdout(`signed in as @${me.body.handle}. ${muted("This terminal is listed under Settings \u203A Terminals.")}
+`);
+    const f = await syncFavorites(io);
+    if (f.status === "synced") io.stdout(muted(`favorites: ${f.count}, synced with your account
+`));
+    return 0;
+  }
+};
+var logout = {
+  name: "logout",
+  usage: "qotm logout",
+  summary: "sign out and revoke this terminal",
+  help: "Your local quotes, favorites and dataset stay on this machine.",
+  async run(args, io) {
+    parse(args, {});
+    const { config: config2 } = qotmPaths(io.env);
+    const session = readSession(config2);
+    if (!session) {
+      io.stdout("not signed in\n");
+      return 0;
+    }
+    const muted = style.muted(useColor(io));
+    let note = "";
+    try {
+      const res = await api(io, "/v1/me/devices/current", { method: "DELETE", token: session.token });
+      if (res.status !== 200 && res.status !== 204 && res.status !== 401)
+        note = ` The API answered ${res.status}; revoke it from Settings \u203A Terminals if it is still listed.`;
+    } catch {
+      note = " The API could not be reached; revoke it from Settings \u203A Terminals.";
+    }
+    clearSession(config2);
+    io.stdout(`signed out. ${muted(`Your local quotes, favorites and dataset stay.${note}`)}
+`);
+    return 0;
+  }
+};
+
+// src/pick.ts
+function pick(candidates, recent, random = Math.random) {
+  if (!candidates.length) return null;
+  const seen = new Set(recent);
+  const fresh = candidates.filter((id) => !seen.has(id));
+  if (fresh.length) return fresh[Math.floor(random() * fresh.length)];
+  const set = new Set(candidates);
+  return [...recent].reverse().find((id) => set.has(id)) ?? candidates[0];
+}
+function closest(input, options) {
+  let best = null;
+  let bestScore = Infinity;
+  for (const o of options) {
+    const d = distance(input, o);
+    if (d < bestScore) [best, bestScore] = [o, d];
+  }
+  return best && bestScore <= Math.max(2, Math.floor(input.length / 3)) ? best : null;
+}
+function distance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cur = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = cur;
+    }
+  }
+  return row[b.length];
+}
+
+// src/quotes.ts
+var fromDataset = (q, topics) => ({
+  id: q.id,
+  text: q.text,
+  type: q.type,
+  author: q.author ? { name: q.author, slug: q.authorSlug } : null,
+  contributor: q.contributor,
+  work: q.work,
+  year: q.year,
+  source: q.source,
+  sourceUrl: q.sourceUrl,
+  topics
+});
+var fromPersonal = (p) => ({
+  id: p.id,
+  text: p.text,
+  type: "personal",
+  author: p.author ? { name: p.author, slug: null } : null,
+  contributor: null,
+  work: p.work,
+  year: p.year,
+  source: null,
+  sourceUrl: null,
+  topics: []
+});
+function credit(q) {
+  if (q.author) return q.author.name;
+  if (q.type === "original") return q.contributor ? `@${q.contributor}` : "a former member";
+  return q.type === "personal" ? "you" : "unknown";
+}
+function sourceLine(q) {
+  const work = [q.source ?? q.work, q.year].filter(Boolean).join(", ");
+  const parts = [work, q.sourceUrl].filter(Boolean);
+  return parts.length ? parts.join(" \xB7 ") : null;
+}
+function formatQuote(q, io, opts = {}) {
+  const color = useColor(io, opts.plain);
+  const columns = opts.columns ?? 80;
+  if (!opts.plain && (io.isTTY || color) && columns >= MIN_COLUMNS) {
+    const personal = q.type === "personal";
+    return render(
+      {
+        text: q.text,
+        credit: credit(q),
+        source: opts.source ? sourceLine(q) ?? "no source on record" : null,
+        ref: personal ? null : `q/${q.id.replace(/^q_/, "")}`,
+        status: personal ? "private" : q.type === "original" ? "\u2713 original" : "\u2713 curated",
+        topics: q.topics.map((t) => t.replace(/-/g, " "))
+      },
+      opts.style ?? "pull",
+      columns,
+      color
+    );
+  }
+  const width = Math.max(20, Math.min(opts.columns ?? 80, 80) - 2);
+  const text = color || io.isTTY && !opts.plain ? wrap(q.text, width) : q.text;
+  const lines = [style.bold(color)(text), `${style.clay(color)("\u2014")}  ${style.muted(color)(credit(q))}`];
+  if (opts.source) {
+    const where = sourceLine(q);
+    lines.push(style.muted(color)(`   ${where ?? "no source on record"}`));
+  }
+  return `${lines.join("\n")}
+`;
+}
+function jsonQuote(q, io, dataset) {
+  return `${JSON.stringify({
+    id: q.id,
+    text: q.text,
+    type: q.type,
+    author: q.author,
+    contributor: q.contributor,
+    work: q.work,
+    year: q.year,
+    source: q.source,
+    sourceUrl: q.sourceUrl,
+    topics: q.topics,
+    url: quoteUrl(io, q.id),
+    dataset: q.type === "personal" ? null : dataset?.meta.version ?? null
+  })}
+`;
+}
+
+// src/commands/quote.ts
+var OUTPUT = {
+  style: { type: "string" },
+  plain: { type: "boolean" },
+  json: { type: "boolean" },
+  source: { type: "boolean" }
+};
+var OPTIONS = {
+  topic: { type: "string" },
+  author: { type: "string" },
+  favorites: { type: "boolean" },
+  personal: { type: "boolean" },
+  ...OUTPUT
+};
+function print(q, io, out, dataset) {
+  const drawn = SETTINGS.style.parse(out.style ?? setting(io, "style"));
+  io.stdout(
+    out.json ? jsonQuote(q, io, dataset) : formatQuote(q, io, { plain: out.plain, source: out.source, style: drawn, columns: io.columns })
+  );
+}
+function unknown(kind, slug, options) {
+  const near = closest(slug, options);
+  throw new CliError(
+    `No ${kind} "${slug}" in your dataset.${near ? ` Did you mean ${near}?` : ""} ${kind === "topic" ? `Topics: ${options.join(", ")}.` : "Authors go by slug: qotm --author dijkstra."}`,
+    2
+  );
+}
+var quote = {
+  name: "quote",
+  usage: "qotm [--topic <slug>] [--author <slug>] [--favorites | --personal] [--source] [--style <name>] [--plain | --json]",
+  summary: "print a quote (the default)",
+  help: `
+Prints one curated quote from the local dataset, avoiding the last 50 shown
+(qotm config set history <n>).
+
+  --topic <slug>    from one topic: qotm --topic debugging
+  --author <slug>   by one author: qotm --author dijkstra
+  --favorites       from your favorites (qotm save)
+  --personal        from your private quotes (qotm add)
+  --source          add where it is from
+  --style <name>    draw it as pull (the default), bubble, card or slab, this
+                    once (qotm config set style <name> to keep one)
+  --plain           just the words and the credit: no shape, colour or
+                    wrapping (also when piped)
+  --json            one JSON object: id, text, type, author, contributor, work,
+                    year, source, sourceUrl, topics, url, dataset
+`,
+  run(args, io) {
+    const { values: v } = parse(args, OPTIONS);
+    if (v.favorites && v.personal) throw new CliError("Choose --favorites or --personal, not both.", 2);
+    const { data } = qotmPaths(io.env);
+    const size = Number(setting(io, "history"));
+    const recent = size ? readHistory(data).shown.slice(0, size).map((s) => s.id) : [];
+    if (v.personal) {
+      if (v.topic || v.author)
+        throw new CliError("--topic and --author pick from the dataset, not your private quotes.", 2);
+      const { quotes } = readPersonal(data);
+      const id = pick(
+        quotes.map((q) => q.id),
+        recent
+      );
+      if (!id) throw new CliError('You have no private quotes yet. Keep one with qotm add "<text>".');
+      print(fromPersonal(quotes.find((q) => q.id === id)), io, v, null);
+      remember(data, id, /* @__PURE__ */ new Date(), size);
+      return 0;
+    }
+    const { dataset, warning } = openDataset(data);
+    try {
+      if (warning) io.stderr(`qotm: ${warning}
+`);
+      if (v.topic && !dataset.topics().includes(v.topic)) unknown("topic", v.topic, dataset.topics());
+      if (v.author && !dataset.authors().includes(v.author)) unknown("author", v.author, dataset.authors());
+      const favorites2 = v.favorites ? readFavorites(data).favorites.map((f) => f.id) : void 0;
+      const candidates = dataset.candidates({ topic: v.topic, author: v.author, ids: favorites2 });
+      const id = pick(candidates, recent);
+      if (!id) {
+        if (v.favorites)
+          throw new CliError(
+            favorites2.length ? "None of your favorites are in this dataset (with these filters)." : "You have no favorites yet. Save the last quote with qotm save."
+          );
+        throw new CliError("No quotes match. Try without --topic or --author.");
+      }
+      print(fromDataset(dataset.quote(id), dataset.topicsOf(id)), io, v, dataset);
+      remember(data, id, /* @__PURE__ */ new Date(), size);
+      return 0;
+    } finally {
+      dataset.close();
+    }
+  }
+};
+var last = {
+  name: "last",
+  usage: "qotm last [--source] [--style <name>] [--plain | --json]",
+  summary: "show the last quote again",
+  run(args, io) {
+    const { values: v } = parse(args, OUTPUT);
+    const { data } = qotmPaths(io.env);
+    const [latest] = readHistory(data).shown;
+    if (!latest) throw new CliError("Nothing shown yet. Run qotm for a quote.");
+    if (latest.id.startsWith("p_")) {
+      const p = readPersonal(data).quotes.find((q) => q.id === latest.id);
+      if (!p) throw new CliError("That private quote is gone. Run qotm for another.");
+      print(fromPersonal(p), io, v, null);
+      return 0;
+    }
+    const { dataset } = openDataset(data);
+    try {
+      const q = dataset.quote(latest.id);
+      if (!q) throw new CliError(`${latest.id} is no longer in your dataset. Run qotm for another.`);
+      print(fromDataset(q, dataset.topicsOf(q.id)), io, v, dataset);
+      return 0;
+    } finally {
+      dataset.close();
+    }
+  }
+};
+
+// src/submission.ts
+var QUOTE_MARKS = /^["“”„'‘’«»]+|["“”„'‘’«»]+$/g;
+var cleanText = (text) => text.replace(/\s+/g, " ").trim().replace(QUOTE_MARKS, "").trim();
+var topicList = (values) => [
+  ...new Set(
+    values.flatMap((v) => v.split(",")).map((t) => t.trim()).filter(Boolean)
+  )
+];
+function validate(input, knownTopics2) {
+  const e = {};
+  const text = cleanText(input.text);
+  if (text.length < 3) e.text = "give the quote, at least 3 characters";
+  else if (text.length > 280) e.text = `at most 280 characters (this is ${text.length})`;
+  if (!input.topics.length) e.topic = "choose at least one topic (--topic debugging)";
+  else if (input.topics.length > 3) e.topic = "at most three topics";
+  else if (knownTopics2?.length) {
+    const unknown2 = input.topics.filter((t) => !knownTopics2.includes(t));
+    if (unknown2.length)
+      e.topic = `unknown topic ${unknown2.join(", ")} (qotm search --web, or: ${knownTopics2.join(", ")})`;
+  }
+  if (input.original) {
+    if (!input.rights) e.rights = "confirm you wrote this quote and may publish it (--rights)";
+    for (const [field, value] of [
+      ["author", input.author],
+      ["source", input.source]
+    ])
+      if (value) e[field] = "an original is yours: leave out --author and --source";
+    return e;
+  }
+  const author = input.author?.trim() ?? "";
+  if (author.length < 2) e.author = 'who said or wrote it (--author "Donald E. Knuth")';
+  else if (author.length > 160) e.author = "at most 160 characters";
+  const source = input.source?.trim() ?? "";
+  if (source.length < 2)
+    e.source = 'where it was said or written (--source "Structured Programming with go to Statements")';
+  else if (source.length > 300) e.source = "at most 300 characters";
+  if (input.year !== void 0 && (!/^-?\d{1,4}$/.test(input.year) || Number(input.year) > 2100 || Number(input.year) < -3e3))
+    e.year = "a year, like 1974";
+  if (input.url !== void 0) {
+    try {
+      const u = new URL(input.url);
+      if (u.protocol !== "https:" && u.protocol !== "http:") throw new Error();
+    } catch {
+      e.url = "a link to the source, starting with https://";
+    }
+  }
+  if (input.context && input.context.trim().length > 1e3) e.context = "at most 1000 characters";
+  return e;
+}
+function body(input) {
+  const text = cleanText(input.text);
+  if (input.original) return { type: "original", text, topics: input.topics, rights: true };
+  return {
+    type: "canonical",
+    text,
+    attribution: input.author.trim(),
+    source: input.source.trim(),
+    ...input.year ? { year: Number(input.year) } : {},
+    ...input.url ? { sourceUrl: input.url } : {},
+    ...input.context?.trim() ? { context: input.context.trim() } : {},
+    topics: input.topics
+  };
+}
+function apiFieldError(message) {
+  const m = /^Validation: (\w+)(?::| -) (.+)$/.exec(message);
+  if (!m) return null;
+  const field = { attribution: "author", sourceUrl: "url", topics: "topic" }[m[1]] ?? m[1];
+  return [field, m[2]];
+}
+
+// src/commands/submit.ts
+var fieldLines = (errors) => Object.entries(errors).map(([field, problem]) => `  ${field.padEnd(8)}${problem}`).join("\n");
+function knownTopics(io) {
+  try {
+    const { dataset } = openDataset(qotmPaths(io.env).data);
+    const topics = dataset.topics();
+    dataset.close();
+    return topics;
+  } catch {
+    return [];
+  }
+}
+async function showMatch(io, token, text, original) {
+  const res = await api(io, "/v1/quotes/match", { method: "POST", token, body: { text } });
+  if (res.status === 401) throw new CliError("Your session ended. Run qotm login, then try again.");
+  if (res.status !== 200) throw new CliError(`The match check failed: ${apiMessage(res)}.`);
+  if (!res.body.match) return null;
+  const m = res.body;
+  const color = useColor(io);
+  const how = m.method === "exact" ? "the same words" : `${Math.round((m.score ?? 0) * 100)}% similar`;
+  io.stdout(
+    `${style.clay(color)("possible match")} ${style.muted(color)(`(${how}):`)} ${m.match.id}  \u201C${m.match.text}\u201D${m.match.author ? ` \u2014 ${m.match.author}` : ""}
+` + style.muted(color)(
+      original ? "Declared original, but it matches a quote on qotm: a moderator checks it before it is published.\n" : "It may already be on qotm; a verifier will compare them.\n"
+    )
+  );
+  return m;
+}
+var submit = {
+  name: "submit",
+  usage: 'qotm submit "<text>" --author <name> --source <title> --topic <slug> [--year] [--url] [--context]\n       qotm submit --original "<text>" --topic <slug> --rights\n       qotm submit <p_id> --topic <slug> --rights',
+  summary: "send a quote for review",
+  help: `
+Canonical quotes (someone else's words) go to a verifier, who checks the
+source; originals (your own words) get an originality check. Signing in is
+needed: qotm login.
+
+  --author <name>     who said or wrote it
+  --source <title>    where: a book, paper, talk or post
+  --year <yyyy>       when (optional)
+  --url <link>        a link to the source (optional)
+  --context <text>    what surrounded it (optional)
+  --topic <slug>      one to three topics: --topic debugging,unix
+  --original          your own words; needs --rights
+  --rights            "I wrote this quote and have the right to publish it"
+  --check             only show whether it matches a quote already on qotm (signed in)
+  --json              print the created quote as JSON
+
+A private quote's id (p_\u2026, from qotm add) submits it as your original.
+`,
+  async run(args, io) {
+    const { values: v, positionals } = parse(
+      args,
+      {
+        author: { type: "string" },
+        source: { type: "string" },
+        year: { type: "string" },
+        url: { type: "string" },
+        context: { type: "string" },
+        topic: { type: "string", multiple: true },
+        original: { type: "boolean" },
+        rights: { type: "boolean" },
+        check: { type: "boolean" },
+        json: { type: "boolean" }
+      },
+      true
+    );
+    let text = positionals.join(" ");
+    let original = Boolean(v.original);
+    if (/^p_[a-z0-9]{8}$/.test(text.trim())) {
+      const kept = readPersonal(qotmPaths(io.env).data).quotes.find((q) => q.id === text.trim());
+      if (!kept) throw new CliError(`No private quote ${text.trim()} here. qotm --personal --json shows yours.`, 2);
+      text = kept.text;
+      original = true;
+    }
+    const input = {
+      original,
+      text,
+      author: v.author,
+      source: v.source,
+      year: v.year,
+      url: v.url,
+      context: v.context,
+      topics: topicList(v.topic ?? []),
+      rights: v.rights
+    };
+    const session = readSession(qotmPaths(io.env).config);
+    if (v.check) {
+      if (cleanLength(text) < 3) throw new CliError('Give the quote to check: qotm submit --check "<text>"', 2);
+      if (!session) throw new CliError("Sign in to check for matches: qotm login.");
+      const m = await showMatch(io, session.token, text, original);
+      if (!m) io.stdout("no match: nothing like it on qotm yet\n");
+      return 0;
+    }
+    const errors = validate(input, knownTopics(io));
+    if (Object.keys(errors).length)
+      throw new CliError(
+        `the quote was not sent. Fix:
+${fieldLines(errors)}
+qotm submit --help shows every option.`,
+        2
+      );
+    if (!session)
+      throw new CliError("Sign in to submit: qotm login. (qotm add keeps a quote on this machine meanwhile.)");
+    await showMatch(io, session.token, input.text, original);
+    const res = await api(io, "/v1/submissions", {
+      method: "POST",
+      token: session.token,
+      body: body(input)
+    });
+    if (res.status === 401) throw new CliError("Your session ended. Run qotm login, then submit again.");
+    if (res.status === 400) {
+      const field = apiFieldError(apiMessage(res));
+      throw new CliError(
+        `the quote was not accepted:
+${field ? fieldLines({ [field[0]]: field[1] }) : `  ${apiMessage(res)}`}`,
+        2
+      );
+    }
+    if (res.status !== 200 && res.status !== 201) throw new CliError(`The quote was not sent: ${apiMessage(res)}.`);
+    if (v.json) {
+      io.stdout(`${JSON.stringify(res.body)}
+`);
+      return 0;
+    }
+    const color = useColor(io);
+    const next = original ? "It gets an originality check, then goes public." : "A verifier checks the source; you get an email when they have decided.";
+    io.stdout(
+      `submitted ${res.body.id} ${style.muted(color)(`(${res.body.status.toLowerCase().replace(/_/g, " ")})`)}
+${style.muted(color)(`${next} ${siteUrl(io)}/my-quotes`)}
+`
+    );
+    return 0;
+  }
+};
+var cleanLength = (text) => text.replace(/\s+/g, " ").trim().length;
+
+// src/commands/sync.ts
+import { createHash } from "node:crypto";
+import { createWriteStream, mkdirSync as mkdirSync2, readdirSync, renameSync as renameSync2, rmSync as rmSync2 } from "node:fs";
+import { join as join6 } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var TEMP = /^qotm\.sqlite\.download-\d+$/;
+var n = (v) => v.toLocaleString("en-US");
+function held(data) {
+  const state = readSync(data);
+  if (!state) return null;
+  try {
+    Dataset.open(join6(data, "qotm.sqlite")).close();
+    return { version: state.version, etag: state.etag };
+  } catch {
+    return null;
+  }
+}
+async function download(m, file, onProgress) {
+  let res;
+  try {
+    res = await fetch(m.url, { headers: { "user-agent": `qotm/${VERSION}` }, signal: AbortSignal.timeout(3e5) });
+  } catch {
+    throw new CliError(
+      `The dataset could not be downloaded from ${new URL(m.url).host}. Your current quotes are unchanged.`
+    );
+  }
+  if (!res.ok || !res.body)
+    throw new CliError(`The dataset download failed (HTTP ${res.status}). Your current quotes are unchanged.`);
+  const hash = createHash("sha256");
+  let bytes = 0;
+  const body2 = Readable.fromWeb(res.body);
+  body2.on("data", (chunk) => {
+    hash.update(chunk);
+    bytes += chunk.length;
+    if (bytes > m.size) body2.destroy(new CliError("The download is larger than the manifest says. It was refused."));
+    else onProgress(bytes);
+  });
+  try {
+    await pipeline(body2, createWriteStream(file));
+  } catch (err) {
+    if (err instanceof CliError) throw err;
+    throw new CliError(`The download was interrupted (${err.message}). Your current quotes are unchanged.`);
+  }
+  if (bytes !== m.size)
+    throw new CliError(`The download stopped at ${n(bytes)} of ${n(m.size)} bytes. Your current quotes are unchanged.`);
+  if (hash.digest("hex") !== m.sha256)
+    throw new CliError(
+      "The download does not match the manifest's sha256, so it was refused. Your current quotes are unchanged."
+    );
+}
+var sync = {
+  name: "sync",
+  usage: "qotm sync [--force] [--json]",
+  summary: "update your quotes to the latest dataset release",
+  help: `
+Fetches the latest dataset release (qotm.sqlite), checks it against its
+manifest (size and sha256), and replaces your copy in one step: an
+interrupted or mismatched download leaves your quotes as they were.
+
+  --force   download even when you already have this release
+  --json    print what was done as JSON
+`,
+  async run(args, io) {
+    const { values: v } = parse(args, { force: { type: "boolean" }, json: { type: "boolean" } });
+    const { config: config2, data } = qotmPaths(io.env);
+    mkdirSync2(data, { recursive: true });
+    for (const f of readdirSync(data)) if (TEMP.test(f)) rmSync2(join6(data, f), { force: true });
+    const session = readSession(config2);
+    const have = held(data);
+    const res = await api(io, "/v1/dataset/manifest", {
+      token: session?.token,
+      headers: {
+        ...have && !v.force && have.etag ? { "if-none-match": have.etag } : {},
+        ...session && have ? { "x-qotm-dataset": have.version } : {}
+      }
+    });
+    const report = async (out, text) => {
+      const favorites2 = await syncFavorites(io);
+      io.stdout(v.json ? `${JSON.stringify({ ...out, favorites: favorites2 })}
+` : text + favoritesLine(io, favorites2));
+      return 0;
+    };
+    if (res.status === 404)
+      return report(
+        { updated: false, reason: "no-release" },
+        "No dataset release has been published yet; you have the quotes that came with qotm.\n"
+      );
+    if (res.status === 304)
+      return report({ updated: false, version: have.version }, `already up to date (${have.version})
+`);
+    if (res.status !== 200) throw new CliError(`The dataset manifest could not be read: ${apiMessage(res)}.`);
+    const m = res.body;
+    if (m.schemaVersion !== SCHEMA_VERSION)
+      throw new CliError(
+        `Release ${m.version} uses dataset schema ${m.schemaVersion}; this qotm reads schema ${SCHEMA_VERSION}. Update qotm: npm i -g qotm`
+      );
+    const etag = res.headers.get("etag");
+    const current = readSync(data);
+    if (!v.force && have && current?.version === m.version && current.sha256 === m.sha256) {
+      writeSync(data, { ...current, etag, syncedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      return report({ updated: false, version: m.version }, `already up to date (${m.version})
+`);
+    }
+    const temp = join6(data, `qotm.sqlite.download-${process.pid}`);
+    const cleanup = () => rmSync2(temp, { force: true });
+    process.once("SIGINT", cleanup);
+    const color = useColor(io);
+    const progress = io.isTTY && !v.json;
+    try {
+      let last2 = -1;
+      await download(m, temp, (bytes) => {
+        const pct = Math.floor(bytes / m.size * 100);
+        if (progress && pct !== last2) {
+          last2 = pct;
+          io.stdout(`\r${style.muted(color)(`downloading ${m.version}\u2026 ${pct}%`)}`);
+        }
+      });
+      if (progress) io.stdout("\r\x1B[2K");
+      try {
+        const ds = Dataset.open(temp);
+        const version = ds.meta.version;
+        ds.close();
+        if (version !== m.version) throw new DatasetError(`it holds ${version}, not ${m.version}`, "corrupt");
+      } catch (err) {
+        throw new CliError(`The download is not a usable dataset (${err.message}). It was refused.`);
+      }
+      renameSync2(temp, join6(data, "qotm.sqlite"));
+    } catch (err) {
+      if (progress) io.stdout("\r\x1B[2K");
+      throw err;
+    } finally {
+      cleanup();
+      process.removeListener("SIGINT", cleanup);
+    }
+    writeSync(data, {
+      version: m.version,
+      schemaVersion: m.schemaVersion,
+      sha256: m.sha256,
+      size: m.size,
+      publishedAt: m.publishedAt,
+      etag,
+      syncedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const c = m.changes;
+    return report(
+      { updated: true, version: m.version, from: have?.version ?? null, changes: c },
+      `synced ${m.version}: ${n(c.eligible)} quotes ${style.muted(color)(`(+${n(c.added)} new, ~${n(c.corrected)} corrected, \u2212${n(c.withdrawn)} withdrawn)`)}
+`
+    );
+  }
+};
+function favoritesLine(io, f) {
+  const m = style.muted(useColor(io));
+  if (f.status === "signed-out") return "";
+  if (f.status === "queued")
+    return m(`favorites: ${f.pending} change${f.pending === 1 ? "" : "s"} waiting (${f.reason})
+`);
+  const skipped = f.skipped.length ? `; ${f.skipped.length} not on qotm.dev, kept here only` : "";
+  return m(`favorites: ${f.count}, synced with @${f.handle ?? "your account"}${skipped}
+`);
+}
+
+// src/commands/tools.ts
+import { createHash as createHash2 } from "node:crypto";
+import { accessSync, constants, mkdirSync as mkdirSync3, readFileSync as readFileSync2, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join7 } from "node:path";
+var JSON_OPT = { json: { type: "boolean" } };
+async function openInBrowser2(io, url2) {
+  if (!io.openUrl) throw new CliError(`Open ${url2} in your browser.`);
+  try {
+    await io.openUrl(url2);
+  } catch {
+    io.stdout(`could not open a browser; the address is ${url2}
+`);
+  }
+}
+var open = {
+  name: "open",
+  usage: "qotm open [<id>]",
+  summary: "open the last quote (or <id>) on qotm.dev",
+  help: "Its page has the source, the context and who verified it.",
+  async run(args, io) {
+    const { positionals } = parse(args, {}, true);
+    let id = positionals[0];
+    if (id && !id.startsWith("q_")) id = `q_${id}`;
+    if (!id) {
+      const [latest] = readHistory(qotmPaths(io.env).data).shown;
+      if (!latest) throw new CliError("Nothing shown yet. Run qotm for a quote, then qotm open.");
+      id = latest.id;
+    }
+    const url2 = quoteUrl(io, id);
+    if (!url2) throw new CliError("That is one of your private quotes; it has no page on qotm.dev.");
+    io.stdout(style.muted(useColor(io))(`opening ${id.replace(/^q_/, "q/")} in your browser
+`));
+    await openInBrowser2(io, url2);
+    return 0;
+  }
+};
+var search = {
+  name: "search",
+  usage: "qotm search <text> [--limit <n>] [--web] [--plain | --json]",
+  summary: "search the quotes in your dataset",
+  help: `
+Searches the text, author and work of every quote in your dataset, offline;
+each word also matches as a prefix (debug finds debugging).
+
+  --limit <n>   at most n results (10)
+  --web         open the search on qotm.dev instead
+  --json        a list of { id, text, author, authorSlug, work, year, url }
+`,
+  async run(args, io) {
+    const { values: v, positionals } = parse(
+      args,
+      { limit: { type: "string" }, web: { type: "boolean" }, plain: { type: "boolean" }, ...JSON_OPT },
+      true
+    );
+    const text = positionals.join(" ").trim();
+    if (!text) throw new CliError("What should qotm search for? qotm search complexity", 2);
+    if (v.web) {
+      const url2 = `${siteUrl(io)}/search?q=${encodeURIComponent(text)}`;
+      io.stdout(style.muted(useColor(io))(`opening the search for "${text}" in your browser
+`));
+      await openInBrowser2(io, url2);
+      return 0;
+    }
+    const limit = v.limit === void 0 ? 10 : Number(v.limit);
+    if (!Number.isInteger(limit) || limit < 1) throw new CliError("--limit is a number of results, like 10.", 2);
+    const { dataset, warning } = openDataset(qotmPaths(io.env).data);
+    try {
+      if (warning) io.stderr(`qotm: ${warning}
+`);
+      const found = dataset.search(text, limit);
+      if (v.json) {
+        io.stdout(
+          `${JSON.stringify(
+            found.map((q) => ({
+              id: q.id,
+              text: q.text,
+              author: q.author,
+              authorSlug: q.authorSlug,
+              work: q.work,
+              year: q.year,
+              url: quoteUrl(io, q.id)
+            }))
+          )}
+`
+        );
+        return 0;
+      }
+      if (!found.length) {
+        io.stdout(
+          `Nothing in your dataset matches "${text}". qotm search ${JSON.stringify(text)} --web searches qotm.dev.
+`
+        );
+        return 0;
+      }
+      const color = useColor(io, v.plain);
+      for (const q of found)
+        io.stdout(
+          `${style.muted(color)(q.id)}  ${q.text} ${style.clay(color)("\u2014")} ${q.author ?? (q.contributor ? `@${q.contributor}` : "a former member")}
+`
+        );
+      return 0;
+    } finally {
+      dataset.close();
+    }
+  }
+};
+var status = {
+  name: "status",
+  usage: "qotm status [--json]",
+  summary: "show your dataset, last sync and account",
+  async run(args, io) {
+    const { values: v } = parse(args, JSON_OPT);
+    const { config: config2, data } = qotmPaths(io.env);
+    const { dataset, from, warning } = openDataset(data);
+    const sync2 = readSync(data);
+    const session = readSession(config2);
+    const favorites2 = readFavorites(data);
+    const report = {
+      dataset: {
+        version: dataset.meta.version,
+        schemaVersion: dataset.meta.schemaVersion,
+        from,
+        quotes: dataset.count(),
+        file: dataset.file
+      },
+      lastSync: sync2?.syncedAt ?? null,
+      account: session ? { handle: session.handle, api: session.api } : null,
+      favorites: favorites2.favorites.length,
+      pendingFavoriteChanges: favorites2.pending.add.length + favorites2.pending.remove.length,
+      privateQuotes: readPersonal(data).quotes.length,
+      api: setting(io, "api")
+    };
+    dataset.close();
+    if (v.json) {
+      io.stdout(`${JSON.stringify(report)}
+`);
+      return 0;
+    }
+    const m = style.muted(useColor(io));
+    const lines = [
+      [
+        "dataset",
+        `${report.dataset.version} \xB7 ${report.dataset.quotes} quotes${from === "snapshot" ? " (the copy that came with qotm)" : ""}`
+      ],
+      ["last sync", report.lastSync ? report.lastSync.replace("T", " ").slice(0, 16) : "never (qotm sync)"],
+      ["account", session ? `@${session.handle ?? "?"}` : "not signed in (qotm login)"],
+      [
+        "favorites",
+        `${report.favorites}${report.pendingFavoriteChanges ? ` (${report.pendingFavoriteChanges} to sync)` : ""}`
+      ],
+      ["private quotes", String(report.privateQuotes)]
+    ];
+    if (warning) io.stderr(`qotm: ${warning}
+`);
+    for (const [k, val] of lines) io.stdout(`${m(k.padEnd(15))}${val}
+`);
+    return 0;
+  }
+};
+var config = {
+  name: "config",
+  usage: "qotm config [get <key> | set <key> <value> | unset <key>] [--json]",
+  summary: "show or change settings",
+  help: `
+Settings (qotm config set <key> <value>):
+${KEYS.map((k) => `  ${k.padEnd(9)}${SETTINGS[k].describe} (default ${SETTINGS[k].default})`).join("\n")}
+
+QOTM_API_URL and QOTM_SITE_URL override api and site for one run.
+`,
+  run(args, io) {
+    const { values: v, positionals } = parse(args, JSON_OPT, true);
+    const [action, key, value] = positionals;
+    if (!action || action === "list") {
+      const all = KEYS.map((k) => resolve(io, k));
+      if (v.json) io.stdout(`${JSON.stringify(Object.fromEntries(all.map((r) => [r.key, r.value])))}
+`);
+      else
+        for (const r of all)
+          io.stdout(
+            `${r.key.padEnd(9)}${r.value}${r.from === "default" ? "  (default)" : r.from === "env" ? "  (from the environment)" : ""}
+`
+          );
+      return 0;
+    }
+    if (action === "get") {
+      const r = resolve(io, assertKey(key));
+      io.stdout(v.json ? `${JSON.stringify({ [r.key]: r.value })}
+` : `${r.value}
+`);
+      return 0;
+    }
+    if (action === "set") {
+      const k = assertKey(key);
+      if (value === void 0) throw new CliError(`Give the value: qotm config set ${k} <value>.`, 2);
+      io.stdout(`${k} = ${setSetting(io, k, value)}
+`);
+      return 0;
+    }
+    if (action === "unset") {
+      const k = assertKey(key);
+      unsetSetting(io, k);
+      io.stdout(`${k} = ${SETTINGS[k].default} (default)
+`);
+      return 0;
+    }
+    throw new CliError(`Unknown config action "${action}": get, set, unset or list.`, 2);
+  }
+};
+var sha256 = (file) => createHash2("sha256").update(readFileSync2(file)).digest("hex");
+var NODE_SUPPORTED = "22.16+ or 24+";
+function nodeOk(version) {
+  const [major = 0, minor = 0] = version.replace(/^v/, "").split(".").map(Number);
+  return major === 22 && minor >= 16 || major >= 24;
+}
+var doctor = {
+  name: "doctor",
+  usage: "qotm doctor [--offline] [--json]",
+  summary: "check the install: Node, folders, dataset, API",
+  help: `
+Checks, and names any problem:
+  node       Node.js ${NODE_SUPPORTED}
+  folders    the config and data folders can be written
+  dataset    the dataset opens, and its sha256 matches its manifest
+  api        the API answers (skipped with --offline)
+`,
+  async run(args, io) {
+    const { values: v } = parse(args, { offline: { type: "boolean" }, ...JSON_OPT });
+    const checks = [];
+    const add2 = (name, ok, detail) => checks.push({ name, ok, detail });
+    add2(
+      "node",
+      nodeOk(process.version),
+      nodeOk(process.version) ? process.version : `${process.version}: qotm needs Node.js ${NODE_SUPPORTED}`
+    );
+    const paths = qotmPaths(io.env);
+    for (const [label, dir] of [
+      ["config folder", paths.config],
+      ["data folder", paths.data]
+    ]) {
+      try {
+        mkdirSync3(dir, { recursive: true });
+        accessSync(dir, constants.W_OK);
+        const probe = join7(dir, `.doctor-${process.pid}`);
+        writeFileSync2(probe, "ok");
+        rmSync3(probe);
+        add2(label, true, dir);
+      } catch (err) {
+        add2(label, false, `${dir} cannot be written: ${err.code ?? err.message}`);
+      }
+    }
+    try {
+      const { dataset, from, warning } = openDataset(paths.data);
+      const file = dataset.file;
+      const label = `${dataset.meta.version}, ${dataset.count()} quotes`;
+      dataset.close();
+      const expected = from === "local" ? readSync(paths.data)?.sha256 : snapshotSha();
+      if (warning) add2("dataset", false, warning);
+      else if (!expected) add2("dataset", true, `${label} (no manifest to check against; qotm sync records one)`);
+      else if (sha256(file) !== expected)
+        add2("dataset", false, `${file} does not match its manifest's sha256: run qotm sync to fetch it again`);
+      else add2("dataset", true, `${label}${from === "snapshot" ? ", the copy that came with qotm" : ""}, sha256 ok`);
+    } catch (err) {
+      add2("dataset", false, `no usable dataset: ${err.message}. Reinstall qotm (npm i -g qotm).`);
+    }
+    if (!v.offline) {
+      const base = setting(io, "api");
+      try {
+        const res = await api(io, "/health", { timeoutMs: 5e3 });
+        add2("api", res.status === 200, res.status === 200 ? `${base} answers` : `${base} answered ${res.status}`);
+      } catch (err) {
+        add2("api", false, err.message);
+      }
+    }
+    const failed = checks.filter((c) => !c.ok);
+    if (v.json) io.stdout(`${JSON.stringify({ ok: !failed.length, checks })}
+`);
+    else {
+      const color = useColor(io);
+      for (const c of checks)
+        io.stdout(`${c.ok ? style.muted(color)("\u2713") : style.clay(color)("\u2717")} ${c.name.padEnd(14)}${c.detail}
+`);
+      io.stdout(
+        failed.length ? `
+${failed.length} problem${failed.length > 1 ? "s" : ""}: ${failed.map((c) => c.name).join(", ")}
+` : "\nall good\n"
+      );
+    }
+    return failed.length ? 1 : 0;
+  }
+};
+function snapshotSha() {
+  try {
+    return JSON.parse(readFileSync2(SNAPSHOT_MANIFEST, "utf8")).sha256;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands.ts
+var COMMANDS = [
+  quote,
+  last,
+  save,
+  unsave,
+  favorites,
+  add,
+  submit,
+  open,
+  search,
+  sync,
+  login,
+  logout,
+  status,
+  config,
+  doctor
+];
+var DEFAULT_COMMAND = quote;
+
+// src/main.ts
+var pad = (s, n2) => s + " ".repeat(Math.max(1, n2 - s.length));
+function usage() {
+  const width = Math.max(10, ...COMMANDS.map((c) => c.name.length)) + 3;
+  const commands = COMMANDS.length ? COMMANDS.map((c) => `  ${pad(c.name, width)}${c.summary}`).join("\n") : "  (none yet)";
+  return `qotm ${VERSION}: one considered programming quote in your terminal.
+
+Usage:
+  qotm <command> [options]
+
+Commands:
+${commands}
+
+Options:
+  -h, --help     show this help, or a command's: qotm help <command>
+  -v, --version  print the version
+
+https://qotm.dev
+`;
+}
+function commandHelp(c) {
+  return `Usage: ${c.usage}
+
+${c.summary}
+${c.help ? `
+${c.help.trim()}
+` : ""}`;
+}
+var find = (name) => COMMANDS.find((c) => c.name === name);
+async function main(argv, io) {
+  const [first, ...rest] = argv;
+  try {
+    if (first === "-v" || first === "--version") {
+      io.stdout(`${VERSION}
+`);
+      return 0;
+    }
+    if (first === void 0 || first.startsWith("-") && !["-h", "--help", "-v", "--version"].includes(first))
+      return await DEFAULT_COMMAND.run(argv, io);
+    if (first === "-h" || first === "--help") {
+      io.stdout(usage());
+      return 0;
+    }
+    if (first === "help") {
+      const target2 = rest[0] ? find(rest[0]) : void 0;
+      if (rest[0] && !target2) throw new CliError(`Unknown command "${rest[0]}". Run qotm --help for the list.`, 2);
+      io.stdout(target2 ? commandHelp(target2) : usage());
+      return 0;
+    }
+    const command = find(first);
+    if (!command) throw new CliError(`Unknown command "${first}". Run qotm --help for the list.`, 2);
+    if (rest.includes("-h") || rest.includes("--help")) {
+      io.stdout(commandHelp(command));
+      return 0;
+    }
+    return await command.run(rest, io);
+  } catch (err) {
+    if (err instanceof CliError) {
+      io.stderr(`qotm: ${err.message}
+`);
+      return err.exitCode;
+    }
+    io.stderr(`qotm: something went wrong: ${err instanceof Error ? err.message : String(err)}
+`);
+    if (io.env.QOTM_DEBUG && err instanceof Error && err.stack) io.stderr(`${err.stack}
+`);
+    return 1;
+  }
+}
+
+// src/cli.ts
+process.removeAllListeners("warning");
+process.on("warning", (w) => {
+  if (w.name === "ExperimentalWarning" && /SQLite/i.test(w.message)) return;
+  process.stderr.write(`${w.name}: ${w.message}
+`);
+});
+var code = await main(process.argv.slice(2), processIo());
+process.exitCode = code;