innernote 0.1.0

package/dist/index.js

@@ -0,0 +1,1969 @@
+#!/usr/bin/env node
+// @bun
+
+// src/config.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+var DEFAULT_API_URL = "https://www.innernote.space";
+var CONFIG_DIR = join(homedir(), ".innernote");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+async function readStored() {
+  try {
+    const raw = await readFile(CONFIG_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function loadConfig() {
+  const stored = await readStored();
+  const envToken = process.env.INNERNOTE_TOKEN?.trim();
+  return {
+    token: envToken || stored.token || null,
+    apiUrl: (process.env.INNERNOTE_API_URL || stored.apiUrl || DEFAULT_API_URL).replace(/\/+$/, ""),
+    fromEnv: Boolean(envToken)
+  };
+}
+async function saveToken(token, apiUrl) {
+  await mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
+  const body = { token, apiUrl };
+  await writeFile(CONFIG_FILE, JSON.stringify(body, null, 2) + `
+`, {
+    mode: 384
+  });
+  await chmod(CONFIG_DIR, 448);
+  await chmod(CONFIG_FILE, 384);
+  return CONFIG_FILE;
+}
+async function clearToken() {
+  const stored = await readStored();
+  if (!stored.token)
+    return false;
+  await rm(CONFIG_FILE, { force: true });
+  return true;
+}
+var configPath = CONFIG_FILE;
+
+// src/client.ts
+function isNotLoggedIn(err) {
+  return err instanceof Error && err.name === "NotLoggedIn";
+}
+function isApiError(err) {
+  return err instanceof Error && err.name === "ApiError";
+}
+
+// src/commands/auth.ts
+import { hostname } from "node:os";
+
+// src/client.ts
+class ApiError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.body = body;
+  }
+  get isRefusal() {
+    return this.status === 402 || this.status === 429;
+  }
+}
+
+class NotLoggedIn extends Error {
+  constructor() {
+    super("Not logged in.");
+    this.name = "NotLoggedIn";
+  }
+}
+function isNotLoggedIn2(err) {
+  return err instanceof Error && err.name === "NotLoggedIn";
+}
+function isApiError2(err) {
+  return err instanceof Error && err.name === "ApiError";
+}
+async function request(path, options = {}) {
+  const config = await loadConfig();
+  return requestWith(config, path, options);
+}
+async function requestWith(config, path, options = {}) {
+  const { method = "GET", body, timeoutMs = 30000, anonymous = false } = options;
+  if (!anonymous && !config.token)
+    throw new NotLoggedIn;
+  const headers = { Accept: "application/json" };
+  if (!anonymous && config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  }
+  if (body !== undefined)
+    headers["Content-Type"] = "application/json";
+  const abort = new AbortController;
+  const timer = setTimeout(() => abort.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${config.apiUrl}${path}`, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: abort.signal
+    });
+  } catch {
+    if (abort.signal.aborted) {
+      throw new Error(`That took longer than ${Math.round(timeoutMs / 1000)}s and was given up on. Try again.`);
+    }
+    throw new Error(`Could not reach ${config.apiUrl}. Check your connection.`);
+  } finally {
+    clearTimeout(timer);
+  }
+  const text = await response.text();
+  let parsed = null;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch {
+    if (!response.ok) {
+      throw new ApiError(`The server returned an unexpected response (${response.status}).`, response.status, {});
+    }
+  }
+  const payload = parsed ?? {};
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new ApiError("That token is not valid any more. Run `innernote login` to reconnect.", 401, payload);
+    }
+    const message = typeof payload.message === "string" && payload.message || typeof payload.error === "string" && payload.error || `Request failed (${response.status}).`;
+    throw new ApiError(message, response.status, payload);
+  }
+  return payload;
+}
+
+// src/ui.ts
+var useColor = process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+var wrap = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
+var dim = wrap("2");
+var bold = wrap("1");
+var green = wrap("32");
+var yellow = wrap("33");
+var red = wrap("31");
+function out(line = "") {
+  process.stdout.write(line + `
+`);
+}
+function note(line = "") {
+  process.stderr.write(line + `
+`);
+}
+function fail(line) {
+  process.stderr.write(`${red("×")} ${line}
+`);
+}
+function ok(line) {
+  process.stderr.write(`${green("✓")} ${line}
+`);
+}
+function ago(ms) {
+  const seconds = Math.max(0, Math.round((Date.now() - ms) / 1000));
+  if (seconds < 60)
+    return "now";
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24)
+    return `${hours}h`;
+  const days = Math.round(hours / 24);
+  if (days < 30)
+    return `${days}d`;
+  return `${Math.round(days / 30)}mo`;
+}
+function oneLine(text, max = 68) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length <= max)
+    return flat;
+  const cut = flat.slice(0, max);
+  const space = cut.lastIndexOf(" ");
+  return (space > max * 0.6 ? cut.slice(0, space) : cut) + "…";
+}
+async function readStdin() {
+  if (process.stdin.isTTY)
+    return null;
+  const chunks = [];
+  for await (const chunk of process.stdin)
+    chunks.push(chunk);
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  return text.length > 0 ? text : null;
+}
+
+// src/brand.ts
+var isTTY = process.stdout.isTTY === true;
+var wantsColor = isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+var truecolor = process.env.COLORTERM === "truecolor" || process.env.COLORTERM === "24bit";
+function paint(r, g, b, s) {
+  if (!wantsColor)
+    return s;
+  if (truecolor)
+    return `\x1B[38;2;${r};${g};${b}m${s}\x1B[0m`;
+  const q = (v) => Math.round(v / 255 * 5);
+  return `\x1B[38;5;${16 + 36 * q(r) + 6 * q(g) + q(b)}m${s}\x1B[0m`;
+}
+function rgb(r, g, b) {
+  if (!wantsColor)
+    return (s) => s;
+  if (truecolor)
+    return (s) => `\x1B[38;2;${r};${g};${b}m${s}\x1B[0m`;
+  const q = (v) => Math.round(v / 255 * 5);
+  const code = 16 + 36 * q(r) + 6 * q(g) + q(b);
+  return (s) => `\x1B[38;5;${code}m${s}\x1B[0m`;
+}
+var plain = (s) => s;
+var sgr = (code) => wantsColor ? (s) => `\x1B[${code}m${s}\x1B[0m` : plain;
+var caramel = rgb(196, 149, 106);
+var caramelDark = rgb(160, 120, 80);
+var bold2 = sgr("1");
+var dim2 = sgr("2");
+var green2 = sgr("32");
+var yellow2 = sgr("33");
+var red2 = sgr("31");
+function width(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function pad(s, n) {
+  return s + " ".repeat(Math.max(0, n - width(s)));
+}
+var canAnimate = isTTY && process.env.TERM !== "dumb" && !process.env.CI;
+var MARK_GRID = [
+  "....#....",
+  "..#...#..",
+  "...#.#...",
+  ".#.....#.",
+  "..#...#..",
+  ".#.....#.",
+  "...#.#...",
+  "..#...#..",
+  "....#...."
+];
+function logoGrid() {
+  return MARK_GRID;
+}
+var MARK_BLOCK_COUNT = MARK_GRID.reduce((n, row) => n + row.split("").filter((c) => c === "#").length, 0);
+function paintRGB(r, g, b, s) {
+  return paint(r, g, b, s);
+}
+function logo(cells = 2) {
+  return MARK_GRID.map((row) => row.split("").map((c) => c === "#" ? "█".repeat(cells) : " ".repeat(cells)).join(""));
+}
+var GLYPHS = {
+  i: ["##", "##", "  ", "##", "##", "##", "##", "##", "##"],
+  n: ["     ", "     ", "     ", "#####", "#   #", "#   #", "#   #", "#   #", "#   #"],
+  e: ["     ", "     ", "     ", " ### ", "#   #", "#####", "#    ", "#   #", " ### "],
+  r: ["    ", "    ", "    ", "# ##", "##  ", "#   ", "#   ", "#   ", "#   "],
+  o: ["     ", "     ", "     ", " ### ", "#   #", "#   #", "#   #", "#   #", " ### "],
+  t: ["    ", " #  ", " #  ", "####", " #  ", " #  ", " #  ", " #  ", " ###"]
+};
+function wordmark(name, gap = 1) {
+  const letters = [...name];
+  if (letters.some((c) => !GLYPHS[c]))
+    return null;
+  const rows = Array(9).fill("");
+  letters.forEach((c, i) => {
+    for (let r = 0;r < 9; r++)
+      rows[r] += (i ? " ".repeat(gap) : "") + GLYPHS[c][r];
+  });
+  return rows.map((r) => r.replace(/#/g, "█").trimEnd());
+}
+function widest(rows) {
+  return Math.max(...rows.map((r) => r.length));
+}
+function lockup(name = "innernote", tagline) {
+  const room = (process.stdout.columns ?? 80) - 5;
+  const mark = logo(2);
+  const markWidth = widest(mark);
+  const word = wordmark(name);
+  if (word) {
+    const gap2 = 3;
+    if (markWidth + gap2 + widest(word) <= room) {
+      const rows2 = mark.map((r, i) => {
+        const right = word[i] ?? "";
+        return right ? `${caramel(r.padEnd(markWidth))}${" ".repeat(gap2)}${bold2(caramel(right))}` : caramel(r.trimEnd());
+      });
+      if (tagline)
+        rows2.push("", `  ${dim2(tagline)}`);
+      return rows2;
+    }
+  }
+  const gap = 3;
+  const beside = Math.max(name.length, tagline?.length ?? 0);
+  if (markWidth + gap + beside <= room) {
+    const mid = Math.floor(mark.length / 2);
+    return mark.map((r, i) => {
+      const left = caramel(r.padEnd(markWidth)) + " ".repeat(gap);
+      if (i === mid)
+        return left + bold2(caramel(name));
+      if (i === mid + 1 && tagline)
+        return left + dim2(tagline);
+      return caramel(r.trimEnd());
+    });
+  }
+  const rows = mark.map((r) => caramel(r.trimEnd()));
+  rows.push("", bold2(caramel(name)));
+  if (tagline)
+    rows.push(dim2(tagline));
+  return rows;
+}
+function banner(tagline = "your voice, from the terminal") {
+  return lockup("innernote", tagline).map((r) => "  " + r).join(`
+`);
+}
+function bar(score, width2 = 10) {
+  const filled = Math.max(0, Math.min(width2, Math.round(score / 100 * width2)));
+  const paint2 = score >= 45 ? green2 : score >= 30 ? caramel : yellow2;
+  return paint2("█".repeat(filled)) + dim2("░".repeat(width2 - filled));
+}
+
+// src/commands/auth.ts
+var PAIR_PAGE = "/dashboard/settings";
+async function login(args) {
+  const config = await loadConfig();
+  if (config.fromEnv) {
+    fail("INNERNOTE_TOKEN is set, so login would have no effect.");
+    note(dim2("Unset it to log in normally, or leave it as is."));
+    return 1;
+  }
+  let code = args.find((a) => !a.startsWith("-"))?.trim();
+  if (!code) {
+    out(`Open ${bold2(config.apiUrl + PAIR_PAGE)} and copy your pairing code.`);
+    out();
+    if (!process.stdin.isTTY) {
+      fail("No pairing code given, and there is no terminal to ask on.");
+      note(dim2("Pass it directly: innernote login ABCD-2345"));
+      return 1;
+    }
+    code = (prompt("Pairing code:") ?? "").trim();
+  }
+  if (!code) {
+    fail("No pairing code given.");
+    return 1;
+  }
+  try {
+    const { token } = await requestWith(config, "/api/devices/token", {
+      method: "POST",
+      anonymous: true,
+      body: {
+        code,
+        client: "cli",
+        label: `cli on ${hostname()}`
+      }
+    });
+    const path = await saveToken(token, config.apiUrl);
+    out();
+    out(banner("connected"));
+    out();
+    note(dim2(`Key saved to ${path}. Revoke it any time in Settings.`));
+    note(dim2("Try: innernote week"));
+    return 0;
+  } catch (err) {
+    fail(err instanceof Error ? err.message : "Pairing failed.");
+    if (isApiError2(err) && err.status === 400) {
+      note(dim2("Codes last ten minutes and work once. Generate a fresh one."));
+    }
+    return 1;
+  }
+}
+async function logout() {
+  const config = await loadConfig();
+  const had = await clearToken();
+  if (config.fromEnv) {
+    note("INNERNOTE_TOKEN is set in this environment, so commands will keep using it.");
+    note(dim2("Unset that variable to fully disconnect."));
+  }
+  if (!had) {
+    note(`Nothing stored at ${configPath}.`);
+    return 0;
+  }
+  ok("Disconnected. The token is gone from this machine.");
+  note(dim2("It still exists on the account until you revoke it in Settings."));
+  return 0;
+}
+
+// src/week.ts
+var DAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+function weekStart(from) {
+  const d = new Date(from);
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() - (d.getDay() + 6) % 7);
+  return d;
+}
+function sameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function renderWeek(posts, now = new Date) {
+  const start = weekStart(now);
+  const columns = [];
+  for (let i = 0;i < 7; i++) {
+    const date = new Date(start);
+    date.setDate(start.getDate() + i);
+    columns.push({
+      label: DAYS[i],
+      date,
+      today: sameDay(date, now),
+      posts: posts.filter((p) => {
+        const when = p.scheduledFor ?? p.publishedAt;
+        return when != null && sameDay(new Date(when), date);
+      })
+    });
+  }
+  const W = 10;
+  const pad2 = (s, n = W) => s + " ".repeat(Math.max(0, n - width(s)));
+  const head = columns.map((c) => {
+    const label = `${c.label} ${c.date.getDate()}`;
+    return pad2(c.today ? caramel(bold2(label)) : dim2(label));
+  }).join("");
+  const cells = columns.map((c) => {
+    if (c.posts.length === 0)
+      return pad2(dim2("·"));
+    const marks = c.posts.map((p) => p.publishedAt ? green2("█") : caramelDark("▓")).join(" ");
+    return pad2(marks);
+  }).join("");
+  const lines = ["  " + head.trimEnd(), "  " + cells.trimEnd()];
+  const listed = posts.slice().sort((a, b) => (a.scheduledFor ?? a.publishedAt ?? 0) - (b.scheduledFor ?? b.publishedAt ?? 0));
+  if (listed.length) {
+    lines.push("");
+    for (const p of listed) {
+      const when = new Date(p.scheduledFor ?? p.publishedAt ?? 0);
+      const day = DAYS[(when.getDay() + 6) % 7];
+      const time = when.toLocaleTimeString(undefined, {
+        hour: "numeric",
+        minute: "2-digit"
+      });
+      const state = p.publishedAt ? green2("published") : caramelDark("scheduled");
+      const text = (p.title || p.content).replace(/\s+/g, " ").slice(0, 44);
+      lines.push(`  ${dim2(`${day} ${time}`.padEnd(12))} ${state}  ${text}`.trimEnd());
+    }
+  }
+  return lines.join(`
+`);
+}
+function emptyWeekNote() {
+  return "Nothing scheduled. The whole week is open.";
+}
+
+// src/draft.ts
+var current = null;
+function setDraft(d) {
+  current = d;
+}
+function getDraft() {
+  return current;
+}
+function updateDraft(patch) {
+  if (current)
+    current = { ...current, ...patch };
+}
+function clearDraft() {
+  current = null;
+}
+var listed = [];
+function rememberList(items) {
+  listed = items;
+}
+function resolveRef(ref) {
+  const n = Number(ref);
+  if (Number.isInteger(n) && n >= 1 && n <= listed.length)
+    return listed[n - 1];
+  const byId = listed.find((i) => i.id === ref);
+  if (byId)
+    return byId;
+  return /^[a-z0-9]{20,}$/.test(ref) ? { id: ref, title: ref } : null;
+}
+
+// src/commands/read.ts
+function parseFlags(args) {
+  return {
+    json: args.includes("--json"),
+    rest: args.filter((a) => !a.startsWith("--"))
+  };
+}
+function powers(scopes) {
+  if (!scopes || scopes.length === 0)
+    return "full access";
+  if (scopes.length === 1)
+    return scopes[0];
+  return `${scopes.slice(0, -1).join(", ")} and ${scopes[scopes.length - 1]}`;
+}
+async function whoami(args) {
+  const { json } = parseFlags(args);
+  const [data, conn] = await Promise.all([
+    request("/api/users"),
+    request("/api/devices/me").catch(() => null)
+  ]);
+  if (json) {
+    out(JSON.stringify({ ...data, connection: conn }, null, 2));
+    return 0;
+  }
+  if (!data.user) {
+    note("Connected, but this account has no profile yet. Finish onboarding in the app.");
+    return 1;
+  }
+  const { name, email, plan } = data.user;
+  out(bold2(name || email || "your account"));
+  if (email && name)
+    out(dim2(email));
+  if (plan)
+    out(dim2(`plan: ${plan}`));
+  if (conn) {
+    out();
+    out(dim2(`this connection: ${conn.label ?? "unnamed"}, can ${powers(conn.scopes)}`));
+    const days = conn.expiresInDays;
+    if (days == null) {
+      out(dim2("does not expire"));
+    } else if (days <= 0) {
+      out(yellow2("expired. Run `innernote login` to reconnect."));
+    } else if (days <= 14) {
+      out(yellow2(`expires in ${days} ${days === 1 ? "day" : "days"}. Reconnect with \`innernote login\`.`));
+    } else {
+      out(dim2(`expires in ${days} days`));
+    }
+  }
+  return 0;
+}
+async function ideas(args) {
+  const { json, rest } = parseFlags(args);
+  const status = rest[0];
+  const query = status ? `?status=${encodeURIComponent(status)}` : "";
+  const data = await request(`/api/ideas${query}`);
+  if (json) {
+    out(JSON.stringify(data.ideas, null, 2));
+    return 0;
+  }
+  if (data.ideas.length === 0) {
+    note('No ideas yet. Capture one with: innernote capture "..."');
+    return 0;
+  }
+  for (const idea of data.ideas) {
+    out(`${dim2(ago(idea.createdAt).padStart(4))}  ${oneLine(idea.content)}`);
+  }
+  note(dim2(`
+${data.ideas.length} ${data.ideas.length === 1 ? "idea" : "ideas"}`));
+  note(dim2(`write "one of these"   to turn it into a post`));
+  return 0;
+}
+async function drafts(args) {
+  const { json, rest } = parseFlags(args);
+  const status = rest[0];
+  const data = await request(`/api/posts${status ? `?status=${encodeURIComponent(status)}` : ""}`);
+  if (json) {
+    out(JSON.stringify(data.posts, null, 2));
+    return 0;
+  }
+  if (data.posts.length === 0) {
+    note("No posts yet. Write one with: write");
+    return 0;
+  }
+  const shown = data.posts.slice(0, 30);
+  rememberList(shown.map((p) => ({ id: p._id, title: (p.title || p.content).replace(/\s+/g, " ") })));
+  for (const [i, post] of shown.entries()) {
+    const n = String(i + 1).padStart(2);
+    out(`${caramel(n)}  ${dim2(post.status.padEnd(9))} ${oneLine(post.title || post.content, 52)}`);
+  }
+  if (data.posts.length > shown.length) {
+    note(dim2(`
+...and ${data.posts.length - shown.length} more`));
+  }
+  note(dim2(`
+open <number>   to work on one`));
+  return 0;
+}
+async function week(args) {
+  const { json } = parseFlags(args);
+  const DAY = 24 * 60 * 60 * 1000;
+  const now = new Date;
+  const monday = new Date(now);
+  monday.setHours(0, 0, 0, 0);
+  monday.setDate(monday.getDate() - (monday.getDay() + 6) % 7);
+  const data = await request(`/api/posts/calendar?start=${monday.getTime()}&end=${monday.getTime() + 7 * DAY}`);
+  if (json) {
+    out(JSON.stringify(data.posts, null, 2));
+    return 0;
+  }
+  out();
+  out(renderWeek(data.posts, now));
+  out();
+  if (data.posts.length === 0) {
+    note(dim2(emptyWeekNote()));
+    note(dim2("`write` to start something"));
+  } else {
+    note(dim2("`drafts` to see everything, `write` to add one"));
+  }
+  return 0;
+}
+
+// src/commands/read.ts
+function parseFlags2(args) {
+  return {
+    json: args.includes("--json"),
+    rest: args.filter((a) => !a.startsWith("--"))
+  };
+}
+
+// src/progress.ts
+var DRAFTING = [
+  { at: 0, text: "reading your voice..." },
+  { at: 3, text: "writing..." },
+  { at: 11, text: "scoring the draft..." },
+  { at: 15, text: "checking it against what you have already published..." },
+  { at: 24, text: "still going, this one is taking a while..." }
+];
+var RESHAPING = [
+  { at: 0, text: "reading your voice..." },
+  { at: 3, text: "reshaping..." },
+  { at: 12, text: "scoring it..." },
+  { at: 20, text: "still going..." }
+];
+async function reveal(text, write) {
+  if (!canAnimate) {
+    write(text + `
+`);
+    return;
+  }
+  const paragraphs = text.split(/\n\s*\n/);
+  for (let i = 0;i < paragraphs.length; i++) {
+    write(paragraphs[i] + (i < paragraphs.length - 1 ? `
+
+` : `
+`));
+    if (i < paragraphs.length - 1)
+      await sleep(70);
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/thinking.ts
+function hash(x, y, salt) {
+  const n = Math.sin(x * 12.9898 + y * 78.233 + salt * 37.719) * 43758.5453;
+  return n - Math.floor(n);
+}
+var CYCLE = 0.8;
+var SPARKS = (() => {
+  const out2 = [];
+  logoGrid().forEach((line, row) => {
+    line.split("").forEach((ch, col) => {
+      if (ch !== "#")
+        return;
+      out2.push({
+        row,
+        col,
+        delay: hash(col, row, 1) * CYCLE,
+        duration: CYCLE * (0.75 + hash(col, row, 2) * 0.6)
+      });
+    });
+  });
+  return out2;
+})();
+function level(s, t) {
+  const phase = ((t - s.delay) % s.duration + s.duration) % s.duration;
+  const up = phase / (s.duration / 2);
+  const tri = up <= 1 ? up : 2 - up;
+  return 0.18 + tri * 0.82;
+}
+function paintAt(level2, s) {
+  const from = [74, 58, 44];
+  const to = [232, 201, 176];
+  const c = (i) => Math.round(from[i] + (to[i] - from[i]) * level2);
+  return paintRGB(c(0), c(1), c(2), s);
+}
+function frame(t) {
+  const grid = logoGrid();
+  const lit = new Map;
+  for (const s of SPARKS)
+    lit.set(`${s.row},${s.col}`, level(s, t));
+  return grid.map((line, row) => line.split("").map((ch, col) => ch === "#" ? paintAt(lit.get(`${row},${col}`) ?? 0.18, "██") : "  ").join(""));
+}
+var HEIGHT = 9;
+
+class Thinking {
+  phases;
+  timer = null;
+  started = 0;
+  drawn = false;
+  label = "";
+  constructor(phases) {
+    this.phases = phases;
+    this.phases = [...phases].sort((a, b) => a.at - b.at);
+  }
+  start() {
+    if (!canAnimate) {
+      if (this.phases[0])
+        process.stderr.write(this.phases[0].text + `
+`);
+      return;
+    }
+    this.started = Date.now();
+    process.stderr.write("\x1B[?25l");
+    this.timer = setInterval(() => this.draw(), 83);
+    this.draw();
+  }
+  draw() {
+    const t = (Date.now() - this.started) / 1000;
+    for (const p of this.phases)
+      if (t >= p.at)
+        this.label = p.text;
+    const rows = frame(t);
+    const mid = Math.floor(rows.length / 2);
+    const out2 = rows.map((r, i) => `  ${r}${i === mid ? `   \x1B[2m${this.label}\x1B[0m` : ""}`).join(`
+`);
+    if (this.drawn)
+      process.stderr.write(`\x1B[${HEIGHT}A`);
+    process.stderr.write(out2.split(`
+`).map((l) => `\x1B[2K${l}`).join(`
+`) + `
+`);
+    this.drawn = true;
+  }
+  stop() {
+    if (!this.timer)
+      return;
+    clearInterval(this.timer);
+    this.timer = null;
+    if (this.drawn) {
+      process.stderr.write(`\x1B[${HEIGHT}A`);
+      process.stderr.write(`\x1B[2K
+`.repeat(HEIGHT));
+      process.stderr.write(`\x1B[${HEIGHT}A`);
+    }
+    process.stderr.write("\x1B[?25h");
+  }
+}
+async function whileThinking(phases, run) {
+  const t = new Thinking(phases);
+  t.start();
+  try {
+    return await run();
+  } finally {
+    t.stop();
+  }
+}
+
+// src/commands/write.ts
+async function capture(args) {
+  const { json, rest } = parseFlags2(args);
+  const piped = await readStdin();
+  const content = (rest.join(" ").trim() || piped || "").trim();
+  if (!content) {
+    fail("Nothing to capture.");
+    note(dim2('Try: innernote capture "the thing you just thought of"'));
+    note(dim2("Or pipe it in: pbpaste | innernote capture"));
+    return 1;
+  }
+  const data = await request("/api/ideas", {
+    method: "POST",
+    body: { content, source: "manual", topics: [] }
+  });
+  if (json) {
+    out(JSON.stringify(data, null, 2));
+    return 0;
+  }
+  ok("Captured.");
+  note(dim2("`ideas` to see them, `write` to turn one into a post"));
+  return 0;
+}
+async function write(args) {
+  const { json, rest } = parseFlags2(args);
+  const flagValue = (name) => {
+    const exact = args.indexOf(`--${name}`);
+    if (exact !== -1 && args[exact + 1] && !args[exact + 1].startsWith("--")) {
+      return args[exact + 1];
+    }
+    const inline = args.find((a) => a.startsWith(`--${name}=`));
+    return inline?.slice(name.length + 3);
+  };
+  const piped = await readStdin();
+  const thought = flagValue("thought") ?? (piped ?? undefined);
+  const topic = rest.filter((a) => a !== thought).join(" ").trim();
+  const format = flagValue("format");
+  const series = flagValue("series");
+  const save = args.includes("--save");
+  const call = () => request("/api/content/generate", {
+    method: "POST",
+    body: {
+      ...topic ? { topic } : {},
+      ...thought ? { rawThought: thought } : {},
+      ...format ? { format } : {},
+      ...series ? { series } : {}
+    },
+    timeoutMs: 120000
+  });
+  const post = json ? await call() : await whileThinking(DRAFTING, call);
+  setDraft({
+    content: post.content,
+    series,
+    seriesSummary: post.seriesSummary ?? undefined,
+    quality: post.qualityScore
+  });
+  if (json) {
+    out(JSON.stringify(post, null, 2));
+    return 0;
+  }
+  out();
+  await reveal(post.content, (chunk) => process.stdout.write(chunk));
+  out();
+  if (!topic && !thought && !series) {
+    note(dim2("No topic given, so innernote picked the subject you have covered least."));
+  }
+  const notes = [`${bar(post.qualityScore)} ${post.qualityScore}`];
+  if (post.revised)
+    notes.push("revised once");
+  if (post.similarity?.regenerated)
+    notes.push("rewritten to avoid repeating an earlier post");
+  else if (post.similarity?.band === "adjacent")
+    notes.push("close to something you already published");
+  note(dim2(notes.join(", ")));
+  if (save) {
+    const saved = await request("/api/posts", {
+      method: "POST",
+      body: {
+        content: post.content,
+        source: "cli",
+        ...series ? { series, seriesSummary: post.seriesSummary } : {}
+      }
+    });
+    updateDraft({ id: saved.id });
+    ok(series ? `Saved into "${series}". ${dim2(saved.id)}` : `Saved as a draft. ${dim2(saved.id)}`);
+  } else {
+    note(dim2("Not saved yet. `save` to keep it, `shape shorter` to change it."));
+  }
+  return 0;
+}
+var SHAPES = [
+  "hook",
+  "example",
+  "specific",
+  "punchier",
+  "shorter",
+  "ending",
+  "warmer",
+  "deslop",
+  "mobile",
+  "question",
+  "takeaway",
+  "jargon"
+];
+async function shape(args) {
+  const { json, rest } = parseFlags2(args);
+  const piped = await readStdin();
+  const chosen = rest.filter((a) => SHAPES.includes(a));
+  const freeText = rest.filter((a) => !SHAPES.includes(a)).join(" ").trim();
+  const held = getDraft();
+  const content = (piped ?? held?.content ?? "").trim();
+  if (!content) {
+    fail("Nothing to reshape.");
+    note(dim2("Write one first, or pipe a post in: pbpaste | innernote shape shorter"));
+    return 1;
+  }
+  if (!chosen.length && !freeText) {
+    fail("Say how to reshape it.");
+    note(dim2(`Named moves: ${SHAPES.join(", ")}`));
+    note(dim2(`Or say it yourself: shape make this about the customer`));
+    return 1;
+  }
+  const asked = chosen.length ? chosen.join(", ") : freeText;
+  const call = () => request("/api/content/revise", {
+    method: "POST",
+    body: chosen.length ? { content, shapes: chosen } : { content, feedback: [freeText] },
+    timeoutMs: 120000
+  });
+  const result = json ? await call() : await whileThinking([{ at: 0, text: `reshaping: ${asked}...` }, ...RESHAPING.slice(1)], call);
+  if (json) {
+    out(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  setDraft({
+    ...held ?? {},
+    content: result.content,
+    quality: result.qualityScore
+  });
+  out();
+  await reveal(result.content, (chunk) => process.stdout.write(chunk));
+  out();
+  const delta = content.length - result.content.length;
+  const shift = delta > 0 ? `${delta} chars shorter` : delta < 0 ? `${-delta} chars longer` : "same length";
+  note(dim2(`${bar(result.qualityScore)} ${result.qualityScore}, ${shift}`));
+  note(dim2(held?.id ? "`save` to update it" : "`save` to keep it"));
+  return 0;
+}
+async function queue(args) {
+  const { json, rest } = parseFlags2(args);
+  const id = rest[0];
+  if (!id) {
+    fail("Which post?");
+    note(dim2("innernote queue <post-id>   (ids come from `innernote drafts --json`)"));
+    return 1;
+  }
+  const result = await request(`/api/posts/${encodeURIComponent(id)}/queue`, { method: "POST", timeoutMs: 60000 });
+  if (json) {
+    out(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  const when = new Date(result.scheduledFor).toLocaleString(undefined, {
+    weekday: "long",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+  ok(`Queued for ${when}. It will go live on its own.`);
+  note(dim2("`week` to see where it landed"));
+  return 0;
+}
+async function save(args) {
+  const { json } = parseFlags2(args);
+  const held = getDraft();
+  if (!held?.content) {
+    fail("Nothing to save.");
+    note(dim2('Write one first: write "your topic"'));
+    return 1;
+  }
+  const saved = await request("/api/posts", {
+    method: "POST",
+    body: {
+      ...held.id ? { id: held.id } : {},
+      content: held.content,
+      source: "cli",
+      ...held.series ? { series: held.series, seriesSummary: held.seriesSummary } : {}
+    }
+  });
+  updateDraft({ id: saved.id });
+  if (json) {
+    out(JSON.stringify(saved, null, 2));
+    return 0;
+  }
+  const id = saved.id ?? held.id;
+  ok(held.id ? `Updated. ${dim2(String(id))}` : held.series ? `Saved into "${held.series}". ${dim2(String(id))}` : `Saved. ${dim2(String(id))}`);
+  note(dim2(`queue ${id}   to schedule it`));
+  return 0;
+}
+async function open(args) {
+  const { json, rest } = parseFlags2(args);
+  const ref = rest[0];
+  if (!ref) {
+    fail("Open which one?");
+    note(dim2("drafts   then   open 3"));
+    return 1;
+  }
+  const target = resolveRef(ref);
+  if (!target) {
+    fail(`No post ${ref} in the last list.`);
+    note(dim2("Run `drafts` to see them numbered."));
+    return 1;
+  }
+  const data = await request("/api/posts");
+  const post = data.posts.find((p) => p._id === target.id);
+  if (!post) {
+    fail("That post is gone.");
+    return 1;
+  }
+  setDraft({ content: post.content, id: post._id });
+  if (json) {
+    out(JSON.stringify(post, null, 2));
+    return 0;
+  }
+  out();
+  out(post.content);
+  out();
+  note(dim2(`${post.status}  ${post._id}`));
+  note(dim2("`shape shorter`, or say it yourself: `shape cut the second half`"));
+  return 0;
+}
+async function ask(args) {
+  const { json, rest } = parseFlags2(args);
+  const message = rest.join(" ").trim();
+  const held = getDraft();
+  if (!message) {
+    fail("Say what you want changed.");
+    note(dim2("ask cut the second half and land it harder"));
+    return 1;
+  }
+  if (!held?.content) {
+    fail("Nothing to talk about.");
+    note(dim2("write one first, or `drafts` then `open 3`"));
+    return 1;
+  }
+  let id = held.id;
+  if (!id) {
+    if (!json)
+      note(dim2("Saving this first, so the assistant can work on it..."));
+    const saved = await request("/api/posts", {
+      method: "POST",
+      body: {
+        content: held.content,
+        source: "cli",
+        ...held.series ? { series: held.series, seriesSummary: held.seriesSummary } : {}
+      }
+    });
+    id = saved.id;
+    updateDraft({ id });
+  }
+  const call = () => request(`/api/posts/${encodeURIComponent(id)}/edit`, { method: "POST", body: { text: message, scope: "whole" }, timeoutMs: 150000 });
+  const result = json ? await call() : await whileThinking([
+    { at: 0, text: "reading the post..." },
+    { at: 3, text: "working on it..." },
+    { at: 14, text: "still going..." }
+  ], call);
+  if (json) {
+    out(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  if (result.changed && result.post) {
+    updateDraft({ content: result.post });
+    out();
+    await reveal(result.post, (chunk) => process.stdout.write(chunk));
+    out();
+    if (result.reply)
+      note(dim2(result.reply));
+    note(dim2("`save` to keep this version, or keep asking"));
+  } else {
+    out();
+    out(result.reply ?? "No change.");
+    out();
+  }
+  return 0;
+}
+async function show(args) {
+  const { json } = parseFlags2(args);
+  const held = getDraft();
+  if (!held?.content) {
+    note("Nothing in hand.");
+    note(dim2("`write` to start one, or `drafts` then `open 3`"));
+    return 0;
+  }
+  if (json) {
+    out(JSON.stringify(held, null, 2));
+    return 0;
+  }
+  out();
+  out(held.content);
+  out();
+  const facts = [
+    held.id ? `saved  ${held.id}` : "not saved",
+    ...held.quality ? [`quality ${held.quality}`] : [],
+    ...held.series ? [`in "${held.series}"`] : []
+  ];
+  note(dim2(facts.join("   ")));
+  note(dim2(held.id ? "`ask` to change it, `queue` to schedule it" : "`ask` to change it, `save` to keep it"));
+  return 0;
+}
+async function drop() {
+  const held = getDraft();
+  if (!held) {
+    note("Nothing in hand.");
+    return 0;
+  }
+  if (!held.id) {
+    note(dim2("That draft was never saved. It is gone."));
+  }
+  clearDraft();
+  ok("Put it down.");
+  note(dim2("`write` to start something, or `drafts` to pick one up"));
+  return 0;
+}
+
+// src/ui.ts
+var useColor2 = process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+var wrap2 = (code) => (s) => useColor2 ? `\x1B[${code}m${s}\x1B[0m` : s;
+var dim3 = wrap2("2");
+var bold3 = wrap2("1");
+var green3 = wrap2("32");
+var yellow3 = wrap2("33");
+var red3 = wrap2("31");
+function out2(line = "") {
+  process.stdout.write(line + `
+`);
+}
+function note2(line = "") {
+  process.stderr.write(line + `
+`);
+}
+function fail2(line) {
+  process.stderr.write(`${red3("×")} ${line}
+`);
+}
+
+// src/brand.ts
+var isTTY2 = process.stdout.isTTY === true;
+var wantsColor2 = isTTY2 && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+var truecolor2 = process.env.COLORTERM === "truecolor" || process.env.COLORTERM === "24bit";
+function rgb2(r, g, b) {
+  if (!wantsColor2)
+    return (s) => s;
+  if (truecolor2)
+    return (s) => `\x1B[38;2;${r};${g};${b}m${s}\x1B[0m`;
+  const q = (v) => Math.round(v / 255 * 5);
+  const code = 16 + 36 * q(r) + 6 * q(g) + q(b);
+  return (s) => `\x1B[38;5;${code}m${s}\x1B[0m`;
+}
+var plain2 = (s) => s;
+var sgr2 = (code) => wantsColor2 ? (s) => `\x1B[${code}m${s}\x1B[0m` : plain2;
+var caramel2 = rgb2(196, 149, 106);
+var caramelDark2 = rgb2(160, 120, 80);
+var bold4 = sgr2("1");
+var dim4 = sgr2("2");
+var green4 = sgr2("32");
+var yellow4 = sgr2("33");
+var red4 = sgr2("31");
+var canAnimate2 = isTTY2 && process.env.TERM !== "dumb" && !process.env.CI;
+var MARK_GRID2 = [
+  "....#....",
+  "..#...#..",
+  "...#.#...",
+  ".#.....#.",
+  "..#...#..",
+  ".#.....#.",
+  "...#.#...",
+  "..#...#..",
+  "....#...."
+];
+var MARK_BLOCK_COUNT2 = MARK_GRID2.reduce((n, row) => n + row.split("").filter((c) => c === "#").length, 0);
+function logo2(cells = 2) {
+  return MARK_GRID2.map((row) => row.split("").map((c) => c === "#" ? "█".repeat(cells) : " ".repeat(cells)).join(""));
+}
+var GLYPHS2 = {
+  i: ["##", "##", "  ", "##", "##", "##", "##", "##", "##"],
+  n: ["     ", "     ", "     ", "#####", "#   #", "#   #", "#   #", "#   #", "#   #"],
+  e: ["     ", "     ", "     ", " ### ", "#   #", "#####", "#    ", "#   #", " ### "],
+  r: ["    ", "    ", "    ", "# ##", "##  ", "#   ", "#   ", "#   ", "#   "],
+  o: ["     ", "     ", "     ", " ### ", "#   #", "#   #", "#   #", "#   #", " ### "],
+  t: ["    ", " #  ", " #  ", "####", " #  ", " #  ", " #  ", " #  ", " ###"]
+};
+function wordmark2(name, gap = 1) {
+  const letters = [...name];
+  if (letters.some((c) => !GLYPHS2[c]))
+    return null;
+  const rows = Array(9).fill("");
+  letters.forEach((c, i) => {
+    for (let r = 0;r < 9; r++)
+      rows[r] += (i ? " ".repeat(gap) : "") + GLYPHS2[c][r];
+  });
+  return rows.map((r) => r.replace(/#/g, "█").trimEnd());
+}
+function widest2(rows) {
+  return Math.max(...rows.map((r) => r.length));
+}
+function lockup2(name = "innernote", tagline) {
+  const room = (process.stdout.columns ?? 80) - 5;
+  const mark = logo2(2);
+  const markWidth = widest2(mark);
+  const word = wordmark2(name);
+  if (word) {
+    const gap2 = 3;
+    if (markWidth + gap2 + widest2(word) <= room) {
+      const rows2 = mark.map((r, i) => {
+        const right = word[i] ?? "";
+        return right ? `${caramel2(r.padEnd(markWidth))}${" ".repeat(gap2)}${bold4(caramel2(right))}` : caramel2(r.trimEnd());
+      });
+      if (tagline)
+        rows2.push("", `  ${dim4(tagline)}`);
+      return rows2;
+    }
+  }
+  const gap = 3;
+  const beside = Math.max(name.length, tagline?.length ?? 0);
+  if (markWidth + gap + beside <= room) {
+    const mid = Math.floor(mark.length / 2);
+    return mark.map((r, i) => {
+      const left = caramel2(r.padEnd(markWidth)) + " ".repeat(gap);
+      if (i === mid)
+        return left + bold4(caramel2(name));
+      if (i === mid + 1 && tagline)
+        return left + dim4(tagline);
+      return caramel2(r.trimEnd());
+    });
+  }
+  const rows = mark.map((r) => caramel2(r.trimEnd()));
+  rows.push("", bold4(caramel2(name)));
+  if (tagline)
+    rows.push(dim4(tagline));
+  return rows;
+}
+function banner2(tagline = "your voice, from the terminal") {
+  return lockup2("innernote", tagline).map((r) => "  " + r).join(`
+`);
+}
+
+// src/help.ts
+var COMMANDS = {
+  login: {
+    summary: "connect this machine to your account",
+    usage: "innernote login [code]",
+    detail: "Opens nothing and asks for no password. Generate a code in Settings, paste it here, and this machine gets its own key. The code works once and expires in ten minutes.",
+    examples: ["innernote login", "innernote login AW4E-7QKN"]
+  },
+  logout: {
+    summary: "forget the key stored on this machine",
+    usage: "innernote logout",
+    detail: "Removes the key from this machine only. It still exists on your account until you revoke it in Settings, which is what you want if the laptop is the thing you lost."
+  },
+  whoami: {
+    summary: "which account is connected, and what this key can do",
+    usage: "innernote whoami",
+    detail: "Shows the account, then what this particular connection is allowed to do and when it stops working. Keys expire, so this is where you find out before it happens."
+  },
+  capture: {
+    summary: "save an idea to your inbox",
+    usage: "innernote capture <text>",
+    detail: "For the thought you do not want to lose and are not ready to write. Reads piped input too, so anything on your clipboard or in a file can go straight in.",
+    examples: [
+      'innernote capture "the onboarding question nobody asks"',
+      "pbpaste | innernote capture"
+    ]
+  },
+  write: {
+    summary: "draft a post in your voice",
+    usage: "innernote write [topic] [options]",
+    detail: "Not a prompt box. innernote already holds your voice, your pillars and what you have published, so give it the subject and let it write. Run it bare and it picks the pillar you have covered least.",
+    options: [
+      ["--thought <text>", "turn a half-formed note into a post, keeping your phrasing"],
+      ["--series <name>", "write into one of your series, so it follows on"],
+      ["--format <name>", "story, listicle, contrarian, ..."],
+      ["--save", "keep it as a draft in the app"]
+    ],
+    examples: [
+      "innernote write",
+      'innernote write "hiring your first engineer" --save',
+      'innernote write --series "Build in Public" --save',
+      "cat notes/monday.md | innernote write"
+    ]
+  },
+  shape: {
+    summary: "push a post shorter, punchier, warmer",
+    usage: "innernote shape <shape...>",
+    detail: "The same twelve moves the app's editor has. In a session it works on the post you are looking at, so shapes compose: shorter, then punchier, each acting on the last result. From a shell it reads the post from stdin instead.",
+    options: [
+      [
+        "named moves",
+        "hook, example, specific, punchier, shorter, ending, warmer, deslop, mobile, question, takeaway, jargon"
+      ],
+      ["anything else", "taken as your own instruction, in your words"]
+    ],
+    examples: [
+      "shape shorter punchier",
+      "shape make this about the customer, not the product",
+      "shape cut the second half and land it harder",
+      "pbpaste | innernote shape shorter | pbcopy"
+    ]
+  },
+  ask: {
+    summary: "talk to the post in your own words",
+    usage: "innernote ask <what you want>",
+    detail: "The Writer, here. The app's composer is a conversation with the post in front of you, and this is the same assistant: it can change the post, answer a question about it, or say it would rather not. `shape` covers the moves that have names; this covers everything else.",
+    examples: [
+      "ask cut the second half and land it harder",
+      "ask this ending is soft, what would you do",
+      "ask say what happened instead of what I learned"
+    ]
+  },
+  save: {
+    summary: "keep the draft you are looking at",
+    usage: "innernote save",
+    detail: "Saves the post currently in hand, the one write or shape just produced. Rerunning write with --save would regenerate it instead, which gives you a different post: the one you liked is gone.",
+    examples: ['write "hiring your first engineer"', "shape shorter", "save"]
+  },
+  show: {
+    summary: "see the post you are holding",
+    usage: "innernote show",
+    detail: "A session scrolls, and the post you are working on goes off the top while you look at your week. This brings it back, and says whether it is saved.",
+    examples: ["show"]
+  },
+  drop: {
+    summary: "put down whatever you are holding",
+    usage: "innernote drop",
+    detail: "Starts clean. An unsaved draft is gone, and it says so before it goes.",
+    examples: ["drop"]
+  },
+  ideas: {
+    summary: "what you have captured",
+    usage: "innernote ideas [status]",
+    examples: ["innernote ideas", "innernote ideas new", "innernote ideas --json | jq -r '.[].content'"]
+  },
+  drafts: {
+    summary: "your posts, numbered",
+    usage: "innernote drafts [status]",
+    detail: "Numbered so you can pick one with `open 3` instead of copying a thirty-two character id. The numbers refer to the list you are looking at and are replaced by the next one.",
+    examples: ["drafts", "drafts ready", "drafts --json | jq -r '.[]._id'"]
+  },
+  open: {
+    summary: "pull a post out of the list and work on it",
+    usage: "innernote open <number>",
+    detail: "Prints the post and holds it, so `shape` and `save` mean that one. Saving after opening UPDATES it rather than making a second copy.",
+    examples: ["drafts", "open 3", "shape shorter", "save"]
+  },
+  week: {
+    summary: "what your week looks like",
+    usage: "innernote week",
+    detail: "Seven days across, so the gaps are visible before you read a word. Published is filled, scheduled is open."
+  },
+  queue: {
+    summary: "schedule a post into your next open slot",
+    usage: "innernote queue <post-id>",
+    detail: "A queued post GOES LIVE on LinkedIn on its own at your next cadence slot. Nobody presses anything again. Needs a connection you allowed to publish: tick that box in Settings when you generate the code.",
+    examples: ["innernote drafts", "innernote queue p17a1yk936ywnan10643efjtc58dhkah"]
+  }
+};
+function commandHelp(name) {
+  const c = COMMANDS[name];
+  if (!c)
+    return null;
+  const lines = ["", `  ${bold2(c.usage)}`, `  ${dim2(c.summary)}`];
+  if (c.detail)
+    lines.push("", wrap3(c.detail, 74, "  "));
+  if (c.options?.length) {
+    lines.push("");
+    for (const [flag, what] of c.options) {
+      lines.push(`  ${caramel(flag.padEnd(18))} ${dim2(what)}`);
+    }
+  }
+  if (c.examples?.length) {
+    lines.push("");
+    for (const ex of c.examples)
+      lines.push(`  ${dim2("$")} ${ex}`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function wrap3(text, width2, indent) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  let line = "";
+  for (const w of words) {
+    if ((line + " " + w).trim().length > width2) {
+      lines.push(indent + line.trim());
+      line = w;
+    } else {
+      line += " " + w;
+    }
+  }
+  if (line.trim())
+    lines.push(indent + line.trim());
+  return lines.join(`
+`);
+}
+
+// src/panel.ts
+function line(content = "") {
+  return `  ${caramelDark("▍")}  ${content}`.trimEnd();
+}
+function margin(rows) {
+  return rows.map(line).join(`
+`);
+}
+function landing(state) {
+  const rows = ["", ...lockup("innernote"), ""];
+  if (state.name) {
+    rows.push(state.name + (state.plan ? dim2(`   ${state.plan}`) : ""));
+  }
+  const sub = [];
+  if (state.powers)
+    sub.push(state.powers);
+  if (typeof state.expiresInDays === "number" && state.expiresInDays <= 14) {
+    sub.push(`key expires in ${state.expiresInDays} ${state.expiresInDays === 1 ? "day" : "days"}`);
+  }
+  if (state.version)
+    sub.push(`v${state.version}`);
+  if (sub.length)
+    rows.push(dim2(sub.join("   ")));
+  if (state.week?.length) {
+    rows.push("", ...state.week);
+  }
+  const counts = [];
+  if (state.ideas)
+    counts.push(`${state.ideas} ${state.ideas === 1 ? "idea" : "ideas"} waiting`);
+  if (state.drafts)
+    counts.push(`${state.drafts} drafts`);
+  if (counts.length)
+    rows.push("", dim2(counts.join("   ")));
+  if (state.next) {
+    rows.push("", `${caramel(state.next.command)}${pad("", Math.max(1, 20 - width(state.next.command)))}${dim2(state.next.why)}`);
+  }
+  rows.push("");
+  return margin(rows);
+}
+function landingDisconnected(apiUrl, version) {
+  return margin([
+    "",
+    ...lockup("innernote", "your voice, from the terminal"),
+    ...version ? [`  ${dim2(`v${version}`)}`] : [],
+    "",
+    dim2("Write LinkedIn posts in your voice, without leaving here."),
+    "",
+    `${caramel("innernote login")}${pad("", 5)}${dim2("connect this machine")}`,
+    dim2(`Get a code at ${apiUrl.replace(/^https?:\/\//, "")}/dashboard/settings`),
+    ""
+  ]);
+}
+function suggest(state) {
+  if (state.scheduled === 0 && state.ideas > 0) {
+    return { command: "innernote ideas", why: "nothing scheduled, and you have things saved" };
+  }
+  if (state.scheduled === 0) {
+    return { command: "innernote write", why: "the week is empty" };
+  }
+  if (state.ideas >= 5) {
+    return { command: "innernote ideas", why: "your inbox is filling up" };
+  }
+  return { command: "innernote write", why: "start something" };
+}
+// package.json
+var package_default = {
+  name: "innernote",
+  version: "0.1.0",
+  description: "Write LinkedIn posts in your voice, from the terminal.",
+  type: "module",
+  bin: {
+    innernote: "dist/index.js"
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: "bun run build.ts",
+    start: "bun run src/index.ts",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "bun run build.ts"
+  },
+  engines: {
+    node: ">=20"
+  },
+  devDependencies: {
+    "@types/bun": "^1.3.14"
+  }
+};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/commands/home.ts
+function powers2(scopes) {
+  if (scopes === undefined)
+    return;
+  if (!scopes || scopes.length === 0)
+    return "full access";
+  if (scopes.length === 1)
+    return scopes[0];
+  return `${scopes.slice(0, -1).join(", ")} and ${scopes[scopes.length - 1]}`;
+}
+async function home() {
+  const config = await loadConfig();
+  if (!config.token) {
+    out();
+    out(landingDisconnected(config.apiUrl, VERSION));
+    out();
+    return 0;
+  }
+  const DAY = 24 * 60 * 60 * 1000;
+  const monday = new Date;
+  monday.setHours(0, 0, 0, 0);
+  monday.setDate(monday.getDate() - (monday.getDay() + 6) % 7);
+  const [me, conn, week2, ideas2, drafts2] = await Promise.all([
+    request("/api/users").catch(() => null),
+    request("/api/devices/me").catch(() => null),
+    request(`/api/posts/calendar?start=${monday.getTime()}&end=${monday.getTime() + 7 * DAY}`).catch(() => null),
+    request("/api/ideas").catch(() => null),
+    request("/api/posts?status=draft").catch(() => null)
+  ]);
+  const posts = week2?.posts ?? [];
+  const scheduled = posts.filter((p) => !p.publishedAt).length;
+  out();
+  out(landing({
+    name: me?.user?.name ?? me?.user?.email ?? undefined,
+    plan: me?.user?.plan,
+    powers: powers2(conn?.scopes),
+    expiresInDays: conn?.expiresInDays ?? null,
+    version: VERSION,
+    week: week2 ? renderWeek(posts).split(`
+`).map((l) => l.replace(/^ {2}/, "")) : null,
+    ideas: ideas2?.ideas.length,
+    drafts: drafts2?.posts.length,
+    next: suggest({
+      scheduled,
+      ideas: ideas2?.ideas.length ?? 0,
+      drafts: drafts2?.posts.length ?? 0
+    })
+  }));
+  out();
+  return 0;
+}
+
+// src/session.ts
+import { createInterface } from "node:readline";
+
+// src/help.ts
+var COMMANDS2 = {
+  login: {
+    summary: "connect this machine to your account",
+    usage: "innernote login [code]",
+    detail: "Opens nothing and asks for no password. Generate a code in Settings, paste it here, and this machine gets its own key. The code works once and expires in ten minutes.",
+    examples: ["innernote login", "innernote login AW4E-7QKN"]
+  },
+  logout: {
+    summary: "forget the key stored on this machine",
+    usage: "innernote logout",
+    detail: "Removes the key from this machine only. It still exists on your account until you revoke it in Settings, which is what you want if the laptop is the thing you lost."
+  },
+  whoami: {
+    summary: "which account is connected, and what this key can do",
+    usage: "innernote whoami",
+    detail: "Shows the account, then what this particular connection is allowed to do and when it stops working. Keys expire, so this is where you find out before it happens."
+  },
+  capture: {
+    summary: "save an idea to your inbox",
+    usage: "innernote capture <text>",
+    detail: "For the thought you do not want to lose and are not ready to write. Reads piped input too, so anything on your clipboard or in a file can go straight in.",
+    examples: [
+      'innernote capture "the onboarding question nobody asks"',
+      "pbpaste | innernote capture"
+    ]
+  },
+  write: {
+    summary: "draft a post in your voice",
+    usage: "innernote write [topic] [options]",
+    detail: "Not a prompt box. innernote already holds your voice, your pillars and what you have published, so give it the subject and let it write. Run it bare and it picks the pillar you have covered least.",
+    options: [
+      ["--thought <text>", "turn a half-formed note into a post, keeping your phrasing"],
+      ["--series <name>", "write into one of your series, so it follows on"],
+      ["--format <name>", "story, listicle, contrarian, ..."],
+      ["--save", "keep it as a draft in the app"]
+    ],
+    examples: [
+      "innernote write",
+      'innernote write "hiring your first engineer" --save',
+      'innernote write --series "Build in Public" --save',
+      "cat notes/monday.md | innernote write"
+    ]
+  },
+  shape: {
+    summary: "push a post shorter, punchier, warmer",
+    usage: "innernote shape <shape...>",
+    detail: "The same twelve moves the app's editor has. In a session it works on the post you are looking at, so shapes compose: shorter, then punchier, each acting on the last result. From a shell it reads the post from stdin instead.",
+    options: [
+      [
+        "named moves",
+        "hook, example, specific, punchier, shorter, ending, warmer, deslop, mobile, question, takeaway, jargon"
+      ],
+      ["anything else", "taken as your own instruction, in your words"]
+    ],
+    examples: [
+      "shape shorter punchier",
+      "shape make this about the customer, not the product",
+      "shape cut the second half and land it harder",
+      "pbpaste | innernote shape shorter | pbcopy"
+    ]
+  },
+  ask: {
+    summary: "talk to the post in your own words",
+    usage: "innernote ask <what you want>",
+    detail: "The Writer, here. The app's composer is a conversation with the post in front of you, and this is the same assistant: it can change the post, answer a question about it, or say it would rather not. `shape` covers the moves that have names; this covers everything else.",
+    examples: [
+      "ask cut the second half and land it harder",
+      "ask this ending is soft, what would you do",
+      "ask say what happened instead of what I learned"
+    ]
+  },
+  save: {
+    summary: "keep the draft you are looking at",
+    usage: "innernote save",
+    detail: "Saves the post currently in hand, the one write or shape just produced. Rerunning write with --save would regenerate it instead, which gives you a different post: the one you liked is gone.",
+    examples: ['write "hiring your first engineer"', "shape shorter", "save"]
+  },
+  show: {
+    summary: "see the post you are holding",
+    usage: "innernote show",
+    detail: "A session scrolls, and the post you are working on goes off the top while you look at your week. This brings it back, and says whether it is saved.",
+    examples: ["show"]
+  },
+  drop: {
+    summary: "put down whatever you are holding",
+    usage: "innernote drop",
+    detail: "Starts clean. An unsaved draft is gone, and it says so before it goes.",
+    examples: ["drop"]
+  },
+  ideas: {
+    summary: "what you have captured",
+    usage: "innernote ideas [status]",
+    examples: ["innernote ideas", "innernote ideas new", "innernote ideas --json | jq -r '.[].content'"]
+  },
+  drafts: {
+    summary: "your posts, numbered",
+    usage: "innernote drafts [status]",
+    detail: "Numbered so you can pick one with `open 3` instead of copying a thirty-two character id. The numbers refer to the list you are looking at and are replaced by the next one.",
+    examples: ["drafts", "drafts ready", "drafts --json | jq -r '.[]._id'"]
+  },
+  open: {
+    summary: "pull a post out of the list and work on it",
+    usage: "innernote open <number>",
+    detail: "Prints the post and holds it, so `shape` and `save` mean that one. Saving after opening UPDATES it rather than making a second copy.",
+    examples: ["drafts", "open 3", "shape shorter", "save"]
+  },
+  week: {
+    summary: "what your week looks like",
+    usage: "innernote week",
+    detail: "Seven days across, so the gaps are visible before you read a word. Published is filled, scheduled is open."
+  },
+  queue: {
+    summary: "schedule a post into your next open slot",
+    usage: "innernote queue <post-id>",
+    detail: "A queued post GOES LIVE on LinkedIn on its own at your next cadence slot. Nobody presses anything again. Needs a connection you allowed to publish: tick that box in Settings when you generate the code.",
+    examples: ["innernote drafts", "innernote queue p17a1yk936ywnan10643efjtc58dhkah"]
+  }
+};
+function commandHelp2(name) {
+  const c = COMMANDS2[name];
+  if (!c)
+    return null;
+  const lines = ["", `  ${bold2(c.usage)}`, `  ${dim2(c.summary)}`];
+  if (c.detail)
+    lines.push("", wrap4(c.detail, 74, "  "));
+  if (c.options?.length) {
+    lines.push("");
+    for (const [flag, what] of c.options) {
+      lines.push(`  ${caramel(flag.padEnd(18))} ${dim2(what)}`);
+    }
+  }
+  if (c.examples?.length) {
+    lines.push("");
+    for (const ex of c.examples)
+      lines.push(`  ${dim2("$")} ${ex}`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function wrap4(text, width2, indent) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  let line2 = "";
+  for (const w of words) {
+    if ((line2 + " " + w).trim().length > width2) {
+      lines.push(indent + line2.trim());
+      line2 = w;
+    } else {
+      line2 += " " + w;
+    }
+  }
+  if (line2.trim())
+    lines.push(indent + line2.trim());
+  return lines.join(`
+`);
+}
+
+// src/session.ts
+var BUILTINS = ["help", "exit", "quit", "clear"];
+var INDENT = "  ";
+function tokenize(line2) {
+  const out3 = [];
+  let cur = "";
+  let quote = null;
+  for (const ch of line2.trim()) {
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      else
+        cur += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (/\s/.test(ch)) {
+      if (cur)
+        out3.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur)
+    out3.push(cur);
+  return out3;
+}
+function indented(run) {
+  const streams = [process.stdout, process.stderr];
+  const originals = streams.map((s) => s.write.bind(s));
+  const pending = ["", ""];
+  streams.forEach((stream, i) => {
+    const write2 = originals[i];
+    stream.write = (chunk, ...rest) => {
+      const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString();
+      if (/\x1b\[(\d*[ABCD]|2K|\?25[lh])/.test(text)) {
+        return write2(chunk, ...rest);
+      }
+      const buffered = pending[i] + text;
+      const lines = buffered.split(`
+`);
+      pending[i] = lines.pop() ?? "";
+      if (lines.length === 0)
+        return true;
+      const out3 = lines.map((l) => l.length ? INDENT + l : l).join(`
+`) + `
+`;
+      return write2(out3, ...rest);
+    };
+  });
+  const restore = () => {
+    streams.forEach((stream, i) => {
+      if (pending[i])
+        originals[i](INDENT + pending[i]);
+      stream.write = originals[i];
+    });
+  };
+  return run().finally(restore);
+}
+async function session(opts) {
+  await opts.intro();
+  const names = [...Object.keys(COMMANDS2), ...BUILTINS];
+  const promptFor = () => {
+    const tag = opts.status?.();
+    return tag ? `  ${dim2(tag)} ${caramelDark("▍")} ` : `  ${caramelDark("▍")} `;
+  };
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: promptFor(),
+    historySize: 200,
+    completer(line2) {
+      const hits = names.filter((n) => n.startsWith(line2));
+      return [hits.length ? hits : names, line2];
+    }
+  });
+  console.log(`  ${dim2("Type a command, or")} ${caramel("help")}${dim2(". Ctrl-C twice to leave.")}
+`);
+  rl.prompt();
+  return new Promise((resolve) => {
+    const queue2 = [];
+    let running = false;
+    let leaving = false;
+    async function drain() {
+      if (running)
+        return;
+      running = true;
+      while (queue2.length) {
+        const [command, ...args] = queue2.shift();
+        if (command === "exit" || command === "quit") {
+          leaving = true;
+          break;
+        }
+        if (command === "clear") {
+          process.stdout.write("\x1B[2J\x1B[H");
+          continue;
+        }
+        if (command === "help") {
+          console.log(args[0] ? commandHelp2(args[0]) ?? whatThereIs() : whatThereIs());
+          continue;
+        }
+        if (!COMMANDS2[command]) {
+          console.log(`${INDENT}${dim2(`No command "${command}". Try`)} ${caramel("help")}${dim2(".")}`);
+          continue;
+        }
+        rl.pause();
+        try {
+          await indented(() => opts.run(command, args));
+        } catch (err) {
+          const text = isNotLoggedIn2(err) ? `${dim2("Not connected. Run")} ${caramel("login")}${dim2(".")}` : err instanceof Error ? err.message : String(err);
+          console.log(`${INDENT}${text}`);
+        }
+        rl.resume();
+      }
+      running = false;
+      if (leaving)
+        rl.close();
+      else {
+        rl.setPrompt(promptFor());
+        rl.prompt();
+      }
+    }
+    rl.on("line", (raw) => {
+      const parts = tokenize(raw);
+      if (parts.length === 0) {
+        if (!running) {
+          rl.setPrompt(promptFor());
+          rl.prompt();
+        }
+        return;
+      }
+      queue2.push(parts);
+      drain();
+    });
+    rl.on("close", () => {
+      console.log(`
+  ${dim2("See you.")}
+`);
+      resolve(0);
+    });
+    let armed = false;
+    let disarm = null;
+    rl.on("SIGINT", () => {
+      if (armed) {
+        rl.close();
+        return;
+      }
+      armed = true;
+      if (disarm)
+        clearTimeout(disarm);
+      disarm = setTimeout(() => {
+        armed = false;
+      }, 2000);
+      process.stdout.write(`
+`);
+      console.log(`  ${dim2("Press Ctrl-C again to leave.")}`);
+      rl.prompt();
+    });
+  });
+}
+function whatThereIs() {
+  const lines = [
+    "",
+    `  ${bold2("The loop")}`,
+    ...[
+      [`${caramel("write")} ${dim2("something")}`, "draft it in your voice"],
+      [caramel("shape shorter"), "or say it yourself: shape cut the ending"],
+      [`${caramel("ask")} ${dim2("what you want")}`, "talk to it, like the app's writer"],
+      [caramel("save"), "keep it"],
+      [`${caramel("queue")} ${dim2("<id>")}`, "schedule it to go live"]
+    ].map(([cmd, why]) => `    ${pad(cmd, 26)}${dim2(why)}`),
+    "",
+    `  ${dim2("Already have one?")}  ${caramel("drafts")}${dim2(", then")} ${caramel("open 3")}`,
+    `  ${dim2("Lost your place?")}   ${caramel("show")}${dim2(" reprints what you are holding")}`,
+    ""
+  ];
+  const groups = [
+    ["Writing", ["write", "shape", "ask", "save", "capture"]],
+    ["Looking", ["show", "ideas", "drafts", "open", "week", "whoami"]],
+    ["Shipping", ["queue"]],
+    ["Connection", ["login", "logout"]]
+  ];
+  for (const [title, cmds] of groups) {
+    lines.push(`  ${bold2(title)}`);
+    for (const c of cmds) {
+      lines.push(`    ${caramel(c.padEnd(9))} ${dim2(COMMANDS2[c]?.summary ?? "")}`);
+    }
+    lines.push("");
+  }
+  lines.push(`  ${dim2("help <command> for detail. drop to put a draft down.")}`, `  ${dim2("exit, or Ctrl-C twice, to leave.")}`, "");
+  return lines.join(`
+`);
+}
+
+// src/draft.ts
+var current2 = null;
+function getDraft2() {
+  return current2;
+}
+
+// src/version.ts
+var VERSION2 = package_default.version;
+
+// src/index.ts
+function commandList() {
+  const groups = [
+    ["Getting connected", ["login", "logout", "whoami"]],
+    ["Writing", ["write", "shape", "ask", "save", "capture"]],
+    ["Looking", ["show", "ideas", "drafts", "open", "week"]],
+    ["Shipping", ["queue"]]
+  ];
+  const lines = [];
+  for (const [title, names] of groups) {
+    lines.push(bold4(title));
+    for (const n of names) {
+      const h = COMMANDS[n];
+      lines.push(`  ${caramel2(n.padEnd(9))} ${h ? dim4(h.summary) : dim4("(no help written)")}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+var HELP = () => [
+  commandList(),
+  `${bold4("Anywhere")}`,
+  `  ${caramel2("--json".padEnd(9))} ${dim4("print raw JSON instead of the human view")}`,
+  `  ${caramel2("--help".padEnd(9))} ${dim4("this, or details for one command")}`,
+  "",
+  dim4("  innernote <command> --help   for what a command actually does"),
+  dim4("  INNERNOTE_API_URL           point at another host, for development")
+].join(`
+`);
+var COMMANDS3 = {
+  login,
+  logout: () => logout(),
+  whoami,
+  capture,
+  write,
+  shape,
+  ask,
+  save,
+  show,
+  drop,
+  ideas,
+  drafts,
+  open,
+  week,
+  queue
+};
+async function main() {
+  const [, , command, ...args] = process.argv;
+  if (!command) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+      return home();
+    return session({
+      intro: async () => {
+        await home();
+      },
+      status: () => {
+        const d = getDraft2();
+        if (!d)
+          return null;
+        return d.id ? "saved" : "unsaved";
+      },
+      run: async (name, rest) => {
+        const h = COMMANDS3[name];
+        return h ? h(rest) : 1;
+      }
+    });
+  }
+  if (command === "--help" || command === "-h" || command === "help") {
+    out2();
+    out2(banner2());
+    out2();
+    out2(HELP());
+    return 0;
+  }
+  if (command === "--version" || command === "-v") {
+    out2(VERSION2);
+    return 0;
+  }
+  const handler = COMMANDS3[command];
+  if (!handler) {
+    fail2(`Unknown command: ${command}`);
+    note2(dim4("Run `innernote --help` to see what there is."));
+    return 1;
+  }
+  if (args.includes("--help")) {
+    out2(commandHelp(command) ?? HELP());
+    return 0;
+  }
+  return handler(args);
+}
+main().then((code) => {
+  process.exitCode = code;
+}).catch((err) => {
+  if (isNotLoggedIn(err)) {
+    fail2("Not connected to an account.");
+    note2(dim4("Run `innernote login` to connect this machine."));
+    process.exitCode = 2;
+    return;
+  }
+  if (isApiError(err)) {
+    fail2(err.message);
+    process.exitCode = err.isRefusal ? 3 : 1;
+    return;
+  }
+  fail2(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});