tuiboard 0.8.1 → 0.8.3

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to **tuiboard** are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.3] - 2026-06-04
+
+### Added
+- **Boot splash.** Launching tuiboard now paints a `tuiboard` wordmark (FIGlet
+  "Rectangles", in the tool's light-yellow accent) the instant the process
+  starts, so the ~1s cold start (runtime + store build + first calendar/agents
+  read) isn't a blank terminal. The launcher animates the booting dots while the
+  dashboard process loads in parallel, then hands the screen over cleanly — no
+  startup time added. Set `TUIBOARD_NO_SPLASH=1` to disable; it also no-ops when
+  output isn't a TTY or the terminal is tiny.
+
+## [0.8.2] - 2026-06-04
+
+### Changed
+- **Consistent date shortcuts everywhere.** `m` now means "tomorrow" in every
+  date input (the schedule modal, the new-event/edit modals, and quick-add),
+  matching the board's `m` = tomorrow key — so `t`/`m` = today/tomorrow whether
+  you press them on a card or type them into a field. `tm`/`tom`/`tomorrow`/
+  `domani` still work as aliases. Hints and the help screen updated to lead with
+  `m`. (Audit of all shortcut surfaces found this was the only divergence; the
+  rest — `t`, `-`/empty to clear, weekdays, ±N — were already aligned.)
+
 ## [0.8.1] - 2026-06-04
 
 ### Added
@@ -152,6 +174,8 @@ First public release on npm. This entry captures the full feature set at launch.
 
 Built with [OpenTUI](https://opentui.com) + SolidJS on Bun.
 
+[0.8.3]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.3
+[0.8.2]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.2
 [0.8.1]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.1
 [0.8.0]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.8.0
 [0.7.3]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.7.3

package/README.md

@@ -261,14 +261,15 @@ show in the picker. Append tokens to the title to set the **time** and **date**:
 
 ```
 Standup 9:00-9:30            # today (or the viewed day), 09:00–09:30
-Lunch tomorrow 12-13         # tomorrow, 12:00–13:00
+Lunch m 12-13                # tomorrow (m), 12:00–13:00
 Review 2026-06-10 15-16      # that date, 15:00–16:00
 Call +3 16:00-16:30          # in 3 days · lun = next Monday also works
 Holiday 2026-12-25 allday    # an all-day event (no time)
 ```
 
 The date defaults to whichever day the Agenda is showing; an explicit date token
-(`t` / `tm` / `+N` / weekday / `YYYY-MM-DD`) overrides it. The time is taken from
+(`t` / `m` / `+N` / weekday / `YYYY-MM-DD` — the same `t`/`m` = today/tomorrow as
+the board keys) overrides it. The time is taken from
 the clicked slot, or `HH:MM-HH:MM`. Add **`allday`** (or `all-day`) anywhere in
 the title to create an all-day event instead — it lands in the top chip strip.
 
@@ -436,6 +437,9 @@ session (until the next terminal resize).
 
 See [CHANGELOG.md](CHANGELOG.md) for the full release history.
 
+- **v0.8** — write to Google Calendar from the Agenda: create, edit, and delete
+  events (opt-in), set their date and time in the modal, plus all-day events in
+  the top strip, consistent `t`/`m` date shortcuts, and a boot splash.
 - **v0.7** — configurable zones: turn the planner, agenda, or agents view off
   (or start it collapsed) via the `zones:` config, so tuiboard can be a pure
   kanban, kanban + calendar, or any mix.

package/bin/tuiboard.ts

@@ -11,10 +11,15 @@
  * any CLI args, and inherit stdio so the TUI keeps the real terminal.
  */
 
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import pkg from "../package.json";
+import { animateBooting, printSplash, showCursor } from "../src/ui/splash.ts";
+
 const here = dirname(fileURLToPath(import.meta.url));
 const appPath = join(here, "..", "src", "app.tsx");
 
@@ -26,10 +31,54 @@ if (process.argv[2] === "calendar-setup") {
 }
 const preload = fileURLToPath(import.meta.resolve("@opentui/solid/preload"));
 
-const result = spawnSync(
+// Paint the splash from the (already-running) launcher and animate its booting
+// dots while the child cold-starts. Using `spawn` (not `spawnSync`) keeps this
+// process's event loop free to run the animation. We MUST stop animating the
+// instant before the child enters OpenTUI's alternate screen, or our writes
+// would land on the dashboard — so the child drops a "ready" flag file just
+// before render() and we poll for it.
+printSplash(pkg.version);
+const stopAnim = animateBooting(pkg.version);
+// The splash hides the cursor; make sure it comes back when the launcher exits
+// (after the child has torn down), so the shell is never left cursor-less.
+process.on("exit", showCursor);
+const readyFlag = join(tmpdir(), `tuiboard-ready-${process.pid}`);
+try { rmSync(readyFlag, { force: true }); } catch { /* ignore */ }
+
+let poll: ReturnType<typeof setInterval> | undefined;
+let safety: ReturnType<typeof setTimeout> | undefined;
+let stopped = false;
+const stopSplash = () => {
+  if (stopped) return;
+  stopped = true;
+  stopAnim();
+  if (poll) clearInterval(poll);
+  if (safety) clearTimeout(safety);
+  try { rmSync(readyFlag, { force: true }); } catch { /* ignore */ }
+};
+poll = setInterval(() => { if (existsSync(readyFlag)) stopSplash(); }, 30);
+safety = setTimeout(stopSplash, 4000); // fallback if the child never signals
+
+// Ctrl-C reaches the child directly (same process group); it cleans up and
+// exits, then we mirror its code below. Ignore the signal here so the launcher
+// doesn't die first and orphan the child mid-teardown.
+process.on("SIGINT", () => {});
+process.on("SIGTERM", () => {});
+
+const child = spawn(
   process.execPath, // the bun binary running this script
   ["--preload", preload, appPath, ...process.argv.slice(2)],
-  { stdio: "inherit" },
+  {
+    stdio: "inherit",
+    env: { ...process.env, TUIBOARD_SPLASH_DONE: "1", TUIBOARD_READY_FLAG: readyFlag },
+  },
 );
-
-process.exit(result.status ?? 1);
+child.on("exit", (code, signal) => {
+  stopSplash();
+  process.exit(code ?? (signal ? 1 : 0));
+});
+child.on("error", (err) => {
+  stopSplash();
+  console.error(String(err));
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuiboard",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Terminal kanban for markdown task boards, with optional Today/Tomorrow planner, 24h agenda + calendar overlay, and a live Claude Code agent view. Use only the panels you want.",
   "type": "module",
   "license": "MIT",

package/src/app.tsx

@@ -12,6 +12,10 @@
  * root layout component changes.
  */
 
+// FIRST import on purpose: paints the boot splash before the heavy imports
+// (OpenTUI) and the ~600ms store build below run. See ui/splash-boot.ts.
+import "~/ui/splash-boot";
+
 import { createMemo } from "solid-js";
 import { render, useKeyboard } from "@opentui/solid";
 
@@ -150,4 +154,18 @@ function App() {
   );
 }
 
+// Signal the launcher (if we were spawned by the `tuiboard` bin) that we're
+// about to take the screen, so it stops animating the splash a beat before
+// OpenTUI enters the alternate buffer — otherwise its writes would land on the
+// dashboard. The short delay gives the launcher's poll a cycle to notice.
+if (process.env.TUIBOARD_READY_FLAG) {
+  try {
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync(process.env.TUIBOARD_READY_FLAG, "1");
+    await new Promise((r) => setTimeout(r, 70));
+  } catch {
+    // Cosmetic only — never block startup on the splash handshake.
+  }
+}
+
 await render(() => <App />, { useMouse: true });

package/src/store/parsers.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "bun:test";
+
+import { isoToday, isoTomorrow } from "./index";
+import { parseDateShortcut, parseQuickAdd, parseTimeBlockShortcut } from "./parsers";
+
+describe("parseDateShortcut", () => {
+  it("maps t / today / oggi to today", () => {
+    expect(parseDateShortcut("t")).toBe(isoToday());
+    expect(parseDateShortcut("today")).toBe(isoToday());
+    expect(parseDateShortcut("oggi")).toBe(isoToday());
+  });
+
+  it("maps m to tomorrow (consistent with the board's m key)", () => {
+    expect(parseDateShortcut("m")).toBe(isoTomorrow());
+  });
+
+  it("keeps tm / tom / tomorrow / domani as tomorrow aliases", () => {
+    expect(parseDateShortcut("tm")).toBe(isoTomorrow());
+    expect(parseDateShortcut("tom")).toBe(isoTomorrow());
+    expect(parseDateShortcut("tomorrow")).toBe(isoTomorrow());
+    expect(parseDateShortcut("domani")).toBe(isoTomorrow());
+  });
+
+  it("is case-insensitive", () => {
+    expect(parseDateShortcut("M")).toBe(isoTomorrow());
+    expect(parseDateShortcut("T")).toBe(isoToday());
+  });
+
+  it("clears on empty / dash, fails on garbage", () => {
+    expect(parseDateShortcut("")).toBeUndefined();
+    expect(parseDateShortcut("-")).toBeUndefined();
+    expect(parseDateShortcut("zzz")).toBeNull();
+  });
+
+  it("parses ISO dates literally", () => {
+    expect(parseDateShortcut("2026-06-10")).toBe("2026-06-10");
+  });
+});
+
+describe("parseQuickAdd date tokens", () => {
+  it("treats a standalone m as tomorrow and strips it from the title", () => {
+    const r = parseQuickAdd("Pay invoice m");
+    expect(r.scheduled).toBe(isoTomorrow());
+    expect(r.title).toBe("Pay invoice");
+  });
+
+  it("treats a standalone t as today", () => {
+    const r = parseQuickAdd("Standup t");
+    expect(r.scheduled).toBe(isoToday());
+    expect(r.title).toBe("Standup");
+  });
+});
+
+describe("parseTimeBlockShortcut", () => {
+  it("parses loose H-H ranges and HH:MM-HH:MM", () => {
+    expect(parseTimeBlockShortcut("9-11")).toEqual({ startMin: 540, endMin: 660 });
+    expect(parseTimeBlockShortcut("09:30-10:45")).toEqual({ startMin: 570, endMin: 645 });
+  });
+
+  it("clears on empty / dash", () => {
+    expect(parseTimeBlockShortcut("")).toBeUndefined();
+    expect(parseTimeBlockShortcut("-")).toBeUndefined();
+  });
+});

package/src/store/parsers.ts

@@ -3,7 +3,7 @@
  *
  * Date input shortcuts:
  *   t                 → today
- *   tm | tom          → tomorrow
+ *   m | tm | tom      → tomorrow  (m matches the board's `m` = tomorrow key)
  *   -N                → N days ago
  *   +N                → N days ahead
  *   lun/mar/.../dom   → next weekday (Italian short)
@@ -47,7 +47,8 @@ export function parseDateShortcut(input: string): string | undefined | null {
   if (s === "-") return undefined;
 
   if (s === "t" || s === "today" || s === "oggi") return isoToday();
-  if (s === "tm" || s === "tom" || s === "tomorrow" || s === "domani") return isoTomorrow();
+  // `m` mirrors the board's `m` = tomorrow key; `tm`/`tom`/… kept as aliases.
+  if (s === "m" || s === "tm" || s === "tom" || s === "tomorrow" || s === "domani") return isoTomorrow();
 
   // Relative ±N
   const rel = s.match(/^([+-])(\d+)$/);
@@ -167,7 +168,7 @@ export interface QuickAddResult {
  * Parse a free-form quick-add string. Recognized tokens:
  *   @name        → assignee
  *   #tag         → tag
- *   t, tm, +N    → scheduled date shortcut
+ *   t, m, +N     → scheduled date shortcut (m = tomorrow, matches the board key)
  *   YYYY-MM-DD   → scheduled date literal
  *   HH:MM-HH:MM  → time block (also sets scheduled to today if missing)
  *   9-11         → 09:00-11:00 time block
@@ -220,10 +221,10 @@ export function parseQuickAdd(input: string): QuickAddResult {
       }
       continue;
     }
-    // Date: t, tm, +N, YYYY-MM-DD
+    // Date: t, m/tm, +N, YYYY-MM-DD
     const lower = tok.toLowerCase();
     if (
-      lower === "t" || lower === "tm" || lower === "tom" ||
+      lower === "t" || lower === "m" || lower === "tm" || lower === "tom" ||
       lower === "today" || lower === "tomorrow" ||
       lower === "oggi" || lower === "domani" ||
       /^[+-]\d+$/.test(lower) ||

package/src/ui/Modal.tsx

@@ -139,7 +139,7 @@ function AddModal(props: { store: TuiStore; columnIndex: number }) {
   return (
     <DialogShell
       title="New task"
-      hint="Quick syntax: @assignee #tag t/tm/+N HH:MM-HH:MM 🔺   ·   Enter to add, Esc to cancel"
+      hint="Quick syntax: @assignee #tag t/m/+N HH:MM-HH:MM 🔺   ·   Enter to add, Esc to cancel"
       width={70}
     >
       <input
@@ -195,7 +195,7 @@ function ScheduleModal(props: { store: TuiStore; modal: Extract<NonNullable<TuiS
   function submit(text: string) {
     const d = parseDateShortcut(text);
     if (d === null) {
-      setError(`Cannot parse "${text}". Try: t · tm · +3 · lun · 2026-06-15`);
+      setError(`Cannot parse "${text}". Try: t · m · +3 · lun · 2026-06-15`);
       return;
     }
     const n = props.store.applyToMarkedOr(props.modal.ref, (r) =>
@@ -208,7 +208,7 @@ function ScheduleModal(props: { store: TuiStore; modal: Extract<NonNullable<TuiS
   return (
     <DialogShell
       title={markedCount > 1 ? `Schedule · ${markedCount} tasks` : "Schedule"}
-      hint="t = today · tm = tomorrow · +3 = in 3 days · lun = next Monday · 2026-06-15 · empty/-clear · Esc to cancel"
+      hint="t = today · m = tomorrow · +3 = in 3 days · lun = next Monday · 2026-06-15 · empty/-clear · Esc to cancel"
       width={70}
     >
       <input
@@ -370,7 +370,7 @@ function EventModal(props: { store: TuiStore }) {
         fallback={
           <DialogShell
             title="New event"
-            hint={`${formatHm(picker()!.startMin)}-${formatHm(picker()!.endMin)} · add a time, a date (tm · +3 · 2026-06-10), or "allday" · Enter add · Esc`}
+            hint={`${formatHm(picker()!.startMin)}-${formatHm(picker()!.endMin)} · add a time, a date (m · +3 · 2026-06-10), or "allday" · Enter add · Esc`}
           >
             <input
               focused
@@ -452,7 +452,7 @@ function EventEditModal(props: { store: TuiStore }) {
     <Show when={sel()}>
       <DialogShell
         title={`Edit event · ${shortDate(sel()!.dateIso)}`}
-        hint="change title, HH:MM-HH:MM, and/or a date (tm · +3 · lun · 2026-06-10) · Enter save · Esc"
+        hint="change title, HH:MM-HH:MM, and/or a date (m · +3 · lun · 2026-06-10) · Enter save · Esc"
       >
         <input
           focused
@@ -813,7 +813,7 @@ function HelpModal(props: { store: TuiStore }) {
         <span style={{ fg: T.text }}>{"  Enter             Toggle done\n"}</span>
         <span style={{ fg: T.text }}>{"  o                 Open detail view\n"}</span>
         <span style={{ fg: T.text }}>{"  e                 Edit task text\n"}</span>
-        <span style={{ fg: T.text }}>{"  s                 Schedule date modal (t/tm/+N/lun/YYYY-MM-DD)\n"}</span>
+        <span style={{ fg: T.text }}>{"  s                 Schedule date modal (t/m/+N/lun/YYYY-MM-DD — same t/m as the board)\n"}</span>
         <span style={{ fg: T.text }}>{"  t                 Set scheduled = today\n"}</span>
         <span style={{ fg: T.text }}>{"  m                 Set scheduled = tomorrow\n"}</span>
         <span style={{ fg: T.text }}>{"  .                 Schedule now — time block at next 15-min slot (30min)\n"}</span>

package/src/ui/splash-boot.ts

@@ -0,0 +1,21 @@
+/**
+ * Side-effect module: paints the boot splash the moment it's imported.
+ *
+ * app.tsx imports this FIRST so the splash prints before `@opentui/solid`
+ * (and the ~600ms store build) load — ES modules run imported modules in
+ * source order, so a first-position side-effect import is the only way to
+ * paint before the heavy imports execute.
+ *
+ * When launched via the `tuiboard` bin, the launcher already printed the splash
+ * (and sets TUIBOARD_SPLASH_DONE), so this no-ops to avoid a double paint.
+ */
+
+import pkg from "../../package.json";
+import { printSplash, showCursor } from "./splash";
+
+if (!process.env.TUIBOARD_SPLASH_DONE) printSplash(pkg.version);
+
+// The splash hides the cursor; guarantee it's restored on every exit path of
+// this process, so quitting never leaves the shell without a cursor. (OpenTUI
+// also restores on clean exit; this is the belt-and-suspenders backstop.)
+process.on("exit", showCursor);

package/src/ui/splash.ts

@@ -0,0 +1,133 @@
+/**
+ * Boot splash — a raw-ANSI "tuiboard" wordmark printed the instant the process
+ * starts, so the ~1s cold-start window (Bun init + module load + store build +
+ * first calendar/agents read) isn't a blank terminal.
+ *
+ * Why raw ANSI and not an OpenTUI component: the slow part is *synchronous* and
+ * happens BEFORE OpenTUI mounts (createTuiStore alone is ~600ms), so a reactive
+ * component can't paint during it. We print straight to stdout first; when
+ * OpenTUI mounts it enters the alternate screen buffer (`?1049h`), which hides
+ * this splash and shows the dashboard. No animation — the main thread is busy
+ * the whole time — so we lean on a static wordmark with a subtle colour ramp.
+ *
+ * The wordmark is the FIGlet "Rectangles" font; the colour is the tool's light
+ * "today" yellow (#eaf6ad), rendered as a gentle top-to-bottom gradient.
+ */
+
+/** "tuiboard" in the FIGlet Rectangles font (4 glyph rows, 31 cols). */
+const WORDMARK = [
+  " _       _ _                 _ ",
+  "| |_ _ _|_| |_ ___ ___ ___ _| |",
+  "|  _| | | | . | . | .'|  _| . |",
+  "|_| |___|_|___|___|__,|_| |___|",
+];
+
+/** Top→bottom gradient of light yellows around the #eaf6ad "today" accent. */
+const GRADIENT: Array<[number, number, number]> = [
+  [244, 250, 200], // #f4fac8
+  [238, 247, 182], // #eef7b6
+  [234, 246, 173], // #eaf6ad  (the tool's todayPale)
+  [224, 239, 154], // #e0ef9a
+];
+
+const SUBTITLE = "terminal kanban · agenda · agents";
+
+const ESC = "\x1b[";
+const RESET = `${ESC}0m`;
+const HIDE_CURSOR = `${ESC}?25l`;
+const SHOW_CURSOR = `${ESC}?25h`;
+const fg = (r: number, g: number, b: number) => `${ESC}38;2;${r};${g};${b}m`;
+const DIM = `${ESC}38;2;110;120;110m`; // muted grey-green for the sub-lines
+
+/** Visible width of a string (the wordmark/subtitle are plain ASCII). */
+function center(line: string, cols: number): string {
+  const pad = Math.max(0, Math.floor((cols - line.length) / 2));
+  return " ".repeat(pad) + line;
+}
+
+/**
+ * Build the full splash frame for a terminal of `cols`×`rows`. Clears the
+ * screen, vertically centres the block, and colours each wordmark row with its
+ * gradient shade. Returns the raw string to write.
+ */
+export function splashFrame(cols: number, rows: number, version: string): string {
+  const blockHeight = WORDMARK.length + 3; // wordmark + blank + subtitle + version
+  const top = Math.max(0, Math.floor((rows - blockHeight) / 2));
+
+  let out = `${ESC}2J${ESC}H`; // clear + home
+  out += "\n".repeat(top);
+
+  WORDMARK.forEach((line, i) => {
+    const [r, g, b] = GRADIENT[Math.min(i, GRADIENT.length - 1)]!;
+    out += fg(r, g, b) + center(line, cols) + RESET + "\n";
+  });
+  out += "\n";
+  out += DIM + center(SUBTITLE, cols) + RESET + "\n";
+  out += DIM + center(bootingLine(version, 0), cols) + RESET;
+  return out;
+}
+
+/** Cycling dot suffixes for the booting line — a gentle left-to-right wave.
+ *  All frames are the same visible width so the centred line never jitters. */
+const BOOT_FRAMES = ["   ", "·  ", "·· ", "···", " ··", "  ·"];
+
+/** The booting line text for animation frame `f` (without colour/centering). */
+function bootingLine(version: string, f: number): string {
+  return `booting v${version} ${BOOT_FRAMES[f % BOOT_FRAMES.length]}`;
+}
+
+/**
+ * Animate the booting line in place (the launcher calls this while the child
+ * cold-starts). Rewrites just that one line — the cursor is already parked on
+ * it after `printSplash`. Returns a `stop` function the caller MUST invoke
+ * before the child takes the screen, so we never draw onto the dashboard.
+ * No-ops (returns a no-op stop) when output isn't an animatable TTY.
+ */
+export function animateBooting(version: string): () => void {
+  if (!process.stdout.isTTY || process.env.TUIBOARD_NO_SPLASH) return () => {};
+  const cols = process.stdout.columns ?? 0;
+  const rows = process.stdout.rows ?? 0;
+  if (cols < 34 || rows < 9) return () => {};
+  let f = 1;
+  const tick = () => {
+    try {
+      process.stdout.write(`\r${ESC}2K` + DIM + center(bootingLine(version, f), cols) + RESET);
+      f++;
+    } catch {
+      /* ignore */
+    }
+  };
+  const handle = setInterval(tick, 230);
+  return () => clearInterval(handle);
+}
+
+/**
+ * Print the splash to stdout if it makes sense to: an interactive TTY, wide and
+ * tall enough not to garble, and not disabled via `TUIBOARD_NO_SPLASH`. Safe to
+ * call more than once; safe to call when not a TTY (it just no-ops).
+ */
+export function printSplash(version: string): void {
+  try {
+    if (!process.stdout.isTTY) return;
+    if (process.env.TUIBOARD_NO_SPLASH) return;
+    const cols = process.stdout.columns ?? 0;
+    const rows = process.stdout.rows ?? 0;
+    if (cols < 34 || rows < 9) return; // too small — skip rather than mangle
+    // Hide the terminal cursor so its blinking bar doesn't sit next to the
+    // booting dots. ALWAYS paired with showCursor() on exit (see splash-boot.ts
+    // and the bin launcher) so the shell never ends up cursor-less.
+    process.stdout.write(HIDE_CURSOR + splashFrame(cols, rows, version));
+  } catch {
+    // Cosmetic only — never let the splash break startup.
+  }
+}
+
+/** Restore the terminal cursor that the splash hid. Idempotent; safe to call on
+ *  every exit path and when no splash was ever shown. */
+export function showCursor(): void {
+  try {
+    if (process.stdout.isTTY) process.stdout.write(SHOW_CURSOR);
+  } catch {
+    /* ignore */
+  }
+}