tuiboard 0.8.3 → 0.9.0

package/src/store/agents.test.ts

@@ -1,181 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  classifyStatus,
-  cwdFromSlug,
-  cwdShort,
-  formatAge,
-  parseTranscript,
-  type LivePidRecord,
-} from "./agents";
-
-describe("cwdFromSlug", () => {
-  it("decodes a Windows drive-letter slug", () => {
-    expect(cwdFromSlug("C--Users-nazza-Documents-Repos-Blits")).toBe(
-      "C:\\Users\\nazza\\Documents\\Repos\\Blits",
-    );
-  });
-
-  it("decodes a POSIX absolute path slug", () => {
-    expect(cwdFromSlug("-home-foo-projects-myrepo")).toBe(
-      "/home/foo/projects/myrepo",
-    );
-  });
-
-  it("decodes a macOS user directory slug", () => {
-    expect(cwdFromSlug("-Users-foo-code-blits")).toBe("/Users/foo/code/blits");
-  });
-
-  it("falls back to host separator for ambiguous bare slugs", () => {
-    // No leading dash and no drive letter — host OS picks the separator.
-    const sep = process.platform === "win32" ? "\\" : "/";
-    expect(cwdFromSlug("workdir-x")).toBe(`workdir${sep}x`);
-  });
-});
-
-describe("cwdShort", () => {
-  it("returns the last 3 parts prefixed with ellipsis when path is long", () => {
-    expect(cwdShort("C:\\Users\\nazza\\Documents\\Repos\\Blits")).toBe(
-      "…Documents\\Repos\\Blits",
-    );
-  });
-
-  it("returns the full path when 3 or fewer parts", () => {
-    expect(cwdShort("C:\\Users\\nazza")).toBe("C:\\Users\\nazza");
-  });
-});
-
-describe("classifyStatus", () => {
-  const now = 1_700_000_000_000; // fixed instant
-  const minutes = (n: number) => n * 60_000;
-  const days = (n: number) => n * 86_400_000;
-
-  it("returns live-busy when PID record fresh AND status busy", () => {
-    const live: LivePidRecord = { mtimeMs: now - minutes(1), status: "busy" };
-    expect(classifyStatus(now, now, live)).toBe("live-busy");
-  });
-
-  it("returns live-idle when PID record fresh AND status idle/missing", () => {
-    const live: LivePidRecord = { mtimeMs: now - minutes(1) };
-    expect(classifyStatus(now, now, live)).toBe("live-idle");
-  });
-
-  it("returns stale-pid when PID record older than 5min", () => {
-    const live: LivePidRecord = { mtimeMs: now - minutes(10), status: "busy" };
-    expect(classifyStatus(now, now, live)).toBe("stale-pid");
-  });
-
-  it("returns dormant when no PID and jsonl mtime within 7 days", () => {
-    expect(classifyStatus(now, now - days(2), undefined)).toBe("dormant");
-  });
-
-  it("returns archived when jsonl mtime older than 7 days and no PID", () => {
-    expect(classifyStatus(now, now - days(10), undefined)).toBe("archived");
-  });
-});
-
-describe("formatAge", () => {
-  const now = 1_700_000_000_000;
-
-  it("formats seconds", () => {
-    expect(formatAge(now - 30_000, now)).toBe("30s");
-  });
-
-  it("formats minutes", () => {
-    expect(formatAge(now - 5 * 60_000, now)).toBe("5m");
-  });
-
-  it("formats hours", () => {
-    expect(formatAge(now - 3 * 3_600_000, now)).toBe("3h");
-  });
-
-  it("formats days", () => {
-    expect(formatAge(now - 2 * 86_400_000, now)).toBe("2d");
-  });
-
-  it("returns dash for zero", () => {
-    expect(formatAge(0, now)).toBe("—");
-  });
-});
-
-describe("parseTranscript", () => {
-  const SAMPLE_JSONL = [
-    JSON.stringify({ type: "user", message: { role: "user", content: "Ciao" }, gitBranch: "main" }),
-    JSON.stringify({
-      type: "assistant",
-      message: {
-        role: "assistant",
-        content: [
-          { type: "text", text: "Hello" },
-          { type: "tool_use", name: "Read" },
-        ],
-      },
-    }),
-    JSON.stringify({ type: "custom-title", customTitle: "Refactor store" }),
-  ].join("\n");
-
-  it("extracts title, last messages, counts, branch", () => {
-    const result = parseTranscript(SAMPLE_JSONL);
-    expect(result.customTitle).toBe("Refactor store");
-    expect(result.lastUser).toBe("Ciao");
-    expect(result.firstHumanUser).toBe("Ciao");
-    expect(result.lastAssistant).toBe("Hello");
-    expect(result.messageCount).toBe(2);
-    expect(result.toolCount).toBe(1);
-    expect(result.gitBranch).toBe("main");
-  });
-
-  it("tolerates malformed lines", () => {
-    const broken = SAMPLE_JSONL + "\n{this is not json\n";
-    const result = parseTranscript(broken);
-    expect(result.lastUser).toBe("Ciao"); // still got the good lines
-  });
-
-  it("handles empty input", () => {
-    const result = parseTranscript("");
-    expect(result.messageCount).toBe(0);
-    expect(result.customTitle).toBeUndefined();
-  });
-
-  it("skips skill-bootstrap and system-tag user messages when picking firstHumanUser", () => {
-    const lines = [
-      // Synthetic skill loader injected by Claude Code on /morning
-      JSON.stringify({
-        type: "user",
-        message: {
-          role: "user",
-          content: "Base directory for this skill: C:\\Users\\nazza\\.claude\\skills\\morning",
-        },
-      }),
-      // System-injected reminder tag
-      JSON.stringify({
-        type: "user",
-        message: { role: "user", content: "<system-reminder>do the thing</system-reminder>" },
-      }),
-      // Real human prompt
-      JSON.stringify({
-        type: "user",
-        message: { role: "user", content: "Davvero buongiorno, partiamo dal recap di ieri" },
-      }),
-    ].join("\n");
-    const result = parseTranscript(lines);
-    expect(result.firstHumanUser).toBe("Davvero buongiorno, partiamo dal recap di ieri");
-    // lastUser still tracks the literal last message regardless
-    expect(result.lastUser).toBe("Davvero buongiorno, partiamo dal recap di ieri");
-  });
-
-  it("returns undefined firstHumanUser when every user message is synthetic", () => {
-    const lines = [
-      JSON.stringify({
-        type: "user",
-        message: { role: "user", content: "Base directory for this skill: X" },
-      }),
-      JSON.stringify({
-        type: "user",
-        message: { role: "user", content: "<task-notification>noisy</task-notification>" },
-      }),
-    ].join("\n");
-    const result = parseTranscript(lines);
-    expect(result.firstHumanUser).toBeUndefined();
-    expect(result.lastUser).toBe("<task-notification>noisy</task-notification>");
-  });
-});

package/src/store/index.test.ts

@@ -1,224 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import type { Config } from "~/config/loader";
-import { createTuiStore, isoAddDays, isoToday } from "./index";
-
-describe("test runner smoke", () => {
-  it("can run a trivial assertion", () => {
-    expect(1 + 1).toBe(2);
-  });
-});
-
-/** Builds a minimal config with no boards — enough to exercise pure UI actions. */
-function emptyConfig(overrides: Partial<Config> = {}): Config {
-  return {
-    root: process.cwd(),
-    loaded: false,
-    boards: [],
-    assignees: [],
-    doneColumn: "Done",
-    archiveColumn: "Archive",
-    zones: { planner: "on", agenda: "on", agents: "on" },
-    ...overrides,
-  };
-}
-
-describe("UI activeZone", () => {
-  it("defaults to 'board' on a fresh store", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    expect(store.state.ui.activeZone).toBe("board");
-  });
-
-  it("setActiveZone updates the zone", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setActiveZone("planner");
-    expect(store.state.ui.activeZone).toBe("planner");
-    store.setActiveZone("timeline");
-    expect(store.state.ui.activeZone).toBe("timeline");
-  });
-
-  it("setActiveZone('planner') resets row to 0", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setCursor(0, 7);
-    store.setActiveZone("planner");
-    expect(store.state.ui.row).toBe(0);
-  });
-});
-
-describe("UI visibleZones", () => {
-  it("defaults to all four zones visible", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    expect(store.state.ui.visibleZones).toEqual({
-      planner: true,
-      board: true,
-      timeline: true,
-      agents: true,
-    });
-  });
-
-  it("setZoneVisible flips one zone without touching others", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setZoneVisible("timeline", false);
-    expect(store.state.ui.visibleZones.timeline).toBe(false);
-    expect(store.state.ui.visibleZones.planner).toBe(true);
-    expect(store.state.ui.visibleZones.board).toBe(true);
-    expect(store.state.ui.visibleZones.agents).toBe(true);
-  });
-
-  it("setZoneVisible('board', false) is ignored — board is load-bearing", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setZoneVisible("board", false);
-    expect(store.state.ui.visibleZones.board).toBe(true);
-  });
-
-  it("hiding the active zone moves activeZone to 'board'", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setActiveZone("timeline");
-    store.setZoneVisible("timeline", false);
-    expect(store.state.ui.activeZone).toBe("board");
-  });
-});
-
-describe("UI cycleActiveZone", () => {
-  it("cycles through all visible zones in fixed order", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setActiveZone("planner");
-    store.cycleActiveZone();
-    expect(store.state.ui.activeZone).toBe("board");
-    store.cycleActiveZone();
-    expect(store.state.ui.activeZone).toBe("timeline");
-    store.cycleActiveZone();
-    expect(store.state.ui.activeZone).toBe("agents");
-    store.cycleActiveZone();
-    expect(store.state.ui.activeZone).toBe("planner"); // wrap
-  });
-
-  it("skips hidden zones", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setZoneVisible("timeline", false);
-    store.setActiveZone("board");
-    store.cycleActiveZone();
-    expect(store.state.ui.activeZone).toBe("agents"); // timeline skipped
-  });
-
-  it("is a no-op when only one zone is visible (board only)", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setZoneVisible("planner", false);
-    store.setZoneVisible("timeline", false);
-    store.setZoneVisible("agents", false);
-    store.cycleActiveZone();
-    expect(store.state.ui.activeZone).toBe("board");
-  });
-});
-
-describe("isoAddDays", () => {
-  it("adds and subtracts days", () => {
-    expect(isoAddDays("2026-05-30", 1)).toBe("2026-05-31");
-    expect(isoAddDays("2026-05-30", -1)).toBe("2026-05-29");
-    expect(isoAddDays("2026-05-30", 0)).toBe("2026-05-30");
-  });
-
-  it("rolls over month and year boundaries", () => {
-    expect(isoAddDays("2026-05-31", 1)).toBe("2026-06-01");
-    expect(isoAddDays("2026-12-31", 1)).toBe("2027-01-01");
-    expect(isoAddDays("2026-03-01", -1)).toBe("2026-02-28");
-  });
-});
-
-describe("Agenda day navigation", () => {
-  it("defaults to today (offset 0)", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    expect(store.state.ui.agendaOffset).toBe(0);
-    expect(store.agendaDate()).toBe(isoToday());
-  });
-
-  it("shifts the viewed day and reflects it in agendaDate()", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.shiftAgendaDay(1);
-    expect(store.state.ui.agendaOffset).toBe(1);
-    expect(store.agendaDate()).toBe(isoAddDays(isoToday(), 1));
-    store.shiftAgendaDay(-3);
-    expect(store.state.ui.agendaOffset).toBe(-2);
-  });
-
-  it("resets to today and clamps to ±365", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.shiftAgendaDay(1000);
-    expect(store.state.ui.agendaOffset).toBe(365);
-    store.resetAgendaDay();
-    expect(store.state.ui.agendaOffset).toBe(0);
-    store.shiftAgendaDay(-1000);
-    expect(store.state.ui.agendaOffset).toBe(-365);
-  });
-
-  it("resets the timeline cursor when changing day", () => {
-    const store = createTuiStore({ config: emptyConfig() });
-    store.setCursor(0, 5);
-    store.shiftAgendaDay(1);
-    expect(store.state.ui.row).toBe(0);
-  });
-});
-
-describe("zones config", () => {
-  it("enables and shows all zones by default", () => {
-    const s = createTuiStore({ config: emptyConfig() });
-    expect(s.state.ui.enabledZones).toEqual({ board: true, planner: true, timeline: true, agents: true });
-    expect(s.state.ui.visibleZones).toEqual({ board: true, planner: true, timeline: true, agents: true });
-  });
-
-  it("disables a zone set to off (never enabled, never visible)", () => {
-    const s = createTuiStore({
-      config: emptyConfig({ zones: { planner: "on", agenda: "off", agents: "off" } }),
-    });
-    expect(s.state.ui.enabledZones.timeline).toBe(false);
-    expect(s.state.ui.enabledZones.agents).toBe(false);
-    expect(s.state.ui.visibleZones.timeline).toBe(false);
-    expect(s.state.ui.visibleZones.agents).toBe(false);
-  });
-
-  it("a hidden zone is enabled but not visible at start; F-key reveals it", () => {
-    const s = createTuiStore({
-      config: emptyConfig({ zones: { planner: "hidden", agenda: "on", agents: "on" } }),
-    });
-    expect(s.state.ui.enabledZones.planner).toBe(true);
-    expect(s.state.ui.visibleZones.planner).toBe(false);
-    s.toggleZoneDesired("planner");
-    expect(s.state.ui.visibleZones.planner).toBe(true);
-  });
-
-  it("F-key toggle is a no-op on a disabled zone", () => {
-    const s = createTuiStore({
-      config: emptyConfig({ zones: { planner: "on", agenda: "off", agents: "on" } }),
-    });
-    s.toggleZoneDesired("timeline");
-    expect(s.state.ui.visibleZones.timeline).toBe(false);
-  });
-
-  it("Shift-Tab cycle skips disabled zones", () => {
-    const s = createTuiStore({
-      config: emptyConfig({ zones: { planner: "on", agenda: "off", agents: "off" } }),
-    });
-    s.setActiveZone("board");
-    s.cycleActiveZone();
-    expect(s.state.ui.activeZone).toBe("planner");
-    s.cycleActiveZone();
-    expect(s.state.ui.activeZone).toBe("board"); // timeline + agents skipped
-  });
-
-  it("responsive fits never force-show a disabled zone", () => {
-    const s = createTuiStore({
-      config: emptyConfig({ zones: { planner: "on", agenda: "off", agents: "on" } }),
-    });
-    s.applyResponsiveFits({ planner: true, timeline: true, agents: true });
-    expect(s.state.ui.visibleZones.timeline).toBe(false); // disabled stays off
-    expect(s.state.ui.visibleZones.agents).toBe(true);
-  });
-
-  it("responsive hides a zone that doesn't fit; it returns when it fits again", () => {
-    const s = createTuiStore({ config: emptyConfig() });
-    s.applyResponsiveFits({ planner: true, timeline: false, agents: true });
-    expect(s.state.ui.visibleZones.timeline).toBe(false);
-    s.applyResponsiveFits({ planner: true, timeline: true, agents: true });
-    expect(s.state.ui.visibleZones.timeline).toBe(true);
-  });
-});

package/src/store/parsers.test.ts

@@ -1,64 +0,0 @@
-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();
-  });
-});