tuiboard 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -5,6 +5,17 @@ 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
@@ -163,6 +174,7 @@ 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

package/README.md

@@ -437,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.2",
+  "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/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 */
+  }
+}