gloomberb 0.4.0 → 0.5.0

package/src/index.tsx

@@ -7,6 +7,7 @@ import { existsSync, mkdirSync } from "fs";
 import { dispatchCli } from "./cli/index";
 import { loadExternalPlugins } from "./plugins/loader";
 import { debugLog } from "./utils/debug-log";
+import { resetTerminalInputState } from "./utils/terminal-input-reset";
 
 async function main() {
   // Intercept console.log/warn/error to capture in debug log
@@ -43,6 +44,10 @@ async function main() {
   // Load or create config
   const config = await initDataDir(dataDir);
 
+  // `bun run --watch` does not guarantee the previous run's renderer can cleanly
+  // restore mouse/raw terminal modes before the next run starts.
+  resetTerminalInputState();
+
   // Create renderer
   const renderer = await createCliRenderer({
     exitOnCtrlC: true,
@@ -63,5 +68,5 @@ async function main() {
 
 main().catch((err) => {
   console.error("Fatal error:", err);
-  process.exit(1);
+  process.exitCode = 1;
 });

package/src/market-data/coordinator.test.ts

@@ -92,6 +92,115 @@ describe("MarketDataCoordinator", () => {
     expect(second.lastGoodData?.length).toBe(2);
   });
 
+  it("uses cached chart data while a wider range request is loading", async () => {
+    const oneYearHistory = [
+      { date: new Date("2024-01-01"), close: 100 },
+      { date: new Date("2024-01-02"), close: 101 },
+    ];
+    const fiveYearHistory = [
+      { date: new Date("2020-01-01"), close: 80 },
+      ...oneYearHistory,
+    ];
+    let requestedFiveYear = false;
+    let resolveFiveYear: (history: PricePoint[] | PromiseLike<PricePoint[]>) => void = (_history) => {
+      throw new Error("expected pending 5Y request");
+    };
+    const provider = createProvider({
+      getPriceHistory: async (_symbol, _exchange, range) => {
+        if (range === "5Y") {
+          return new Promise<PricePoint[]>((resolve) => {
+            requestedFiveYear = true;
+            resolveFiveYear = resolve;
+          });
+        }
+        return oneYearHistory;
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+
+    await coordinator.loadChart({
+      instrument,
+      bufferRange: "1Y",
+      granularity: "range",
+    });
+    const pending = coordinator.loadChart({
+      instrument,
+      bufferRange: "5Y",
+      granularity: "range",
+    });
+
+    const loadingEntry = coordinator.getChartEntry({
+      instrument,
+      bufferRange: "5Y",
+      granularity: "range",
+    });
+    expect(loadingEntry.phase).toBe("refreshing");
+    expect(loadingEntry.data?.map((point) => point.close)).toEqual([100, 101]);
+
+    expect(requestedFiveYear).toBe(true);
+    resolveFiveYear(fiveYearHistory);
+    const readyEntry = await pending;
+    expect(readyEntry.phase).toBe("ready");
+    expect(readyEntry.data?.map((point) => point.close)).toEqual([80, 100, 101]);
+  });
+
+  it("uses cached manual-resolution data while a wider resolution range is loading", async () => {
+    const oneYearHistory = [
+      { date: new Date("2024-01-01"), close: 100 },
+      { date: new Date("2024-01-02"), close: 101 },
+    ];
+    const fiveYearHistory = [
+      { date: new Date("2020-01-01"), close: 80 },
+      ...oneYearHistory,
+    ];
+    let requestedFiveYear = false;
+    let resolveFiveYear: (history: PricePoint[] | PromiseLike<PricePoint[]>) => void = (_history) => {
+      throw new Error("expected pending 5Y request");
+    };
+    const provider = createProvider({
+      getPriceHistoryForResolution: async (_symbol, _exchange, range) => {
+        if (range === "5Y") {
+          return new Promise<PricePoint[]>((resolve) => {
+            requestedFiveYear = true;
+            resolveFiveYear = resolve;
+          });
+        }
+        return oneYearHistory;
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+
+    await coordinator.loadChart({
+      instrument,
+      bufferRange: "1Y",
+      granularity: "resolution",
+      resolution: "1d",
+    });
+    const pending = coordinator.loadChart({
+      instrument,
+      bufferRange: "5Y",
+      granularity: "resolution",
+      resolution: "1d",
+    });
+
+    const loadingEntry = coordinator.getChartEntry({
+      instrument,
+      bufferRange: "5Y",
+      granularity: "resolution",
+      resolution: "1d",
+    });
+    expect(loadingEntry.phase).toBe("refreshing");
+    expect(loadingEntry.data?.map((point) => point.close)).toEqual([100, 101]);
+
+    expect(requestedFiveYear).toBe(true);
+    resolveFiveYear(fiveYearHistory);
+    const readyEntry = await pending;
+    expect(readyEntry.phase).toBe("ready");
+    expect(readyEntry.data?.map((point) => point.close)).toEqual([80, 100, 101]);
+  });
+
   it("normalizes descending chart history before storing it", async () => {
     const provider = createProvider({
       getPriceHistory: async () => [
@@ -124,7 +233,7 @@ describe("MarketDataCoordinator", () => {
     const instrument = { symbol: "MSFT", exchange: "NASDAQ" };
 
     coordinator.subscribeQuotes([{ instrument }]);
-    const onStreamed = streamed;
+    const onStreamed = streamed as ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null;
     if (!onStreamed) throw new Error("expected streaming callback");
     onStreamed(
       { symbol: "MSFT", exchange: "NASDAQ" },
@@ -162,7 +271,7 @@ describe("MarketDataCoordinator", () => {
       resolution: "1d",
     });
 
-    expect(requested).toEqual({ range: "1Y", resolution: "1d" });
+    expect(requested as { range: string; resolution: string } | null).toEqual({ range: "1Y", resolution: "1d" });
     expect(entry.data?.length).toBe(2);
   });
 
@@ -196,7 +305,7 @@ describe("MarketDataCoordinator", () => {
 
     await coordinator.loadSnapshot(instrument);
     coordinator.subscribeQuotes([{ instrument }]);
-    const onStreamed = streamed;
+    const onStreamed = streamed as ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null;
     if (!onStreamed) throw new Error("expected streaming callback");
     onStreamed(
       {
@@ -292,7 +401,7 @@ describe("MarketDataCoordinator", () => {
 
     await coordinator.loadSnapshot(instrument);
     coordinator.subscribeQuotes([{ instrument }]);
-    const onStreamed = streamed;
+    const onStreamed = streamed as ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null;
     if (!onStreamed) throw new Error("expected streaming callback");
     onStreamed(
       { symbol: "IQE", exchange: "LSE" },
@@ -347,7 +456,7 @@ describe("MarketDataCoordinator", () => {
 
       await coordinator.loadSnapshot(instrument);
       coordinator.subscribeQuotes([{ instrument }]);
-      const onStreamed = streamed;
+      const onStreamed = streamed as ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null;
       if (!onStreamed) throw new Error("expected streaming callback");
       onStreamed(
         { symbol: "HY9H", exchange: "FWB2" },

package/src/market-data/coordinator.ts

@@ -8,6 +8,7 @@ import {
   buildArticleSummaryKey,
   buildChartKey,
   buildFxKey,
+  buildInstrumentKey,
   buildTickerFinancialsSnapshot,
   buildNewsKey,
   buildOptionsKey,
@@ -24,9 +25,11 @@ import {
 import { traceMarketData } from "./trace";
 import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../utils/price-history";
 import { hasFreshQuoteForCurrentSession, isQuoteStaleForCurrentSession } from "../utils/quote-freshness";
+import { TIME_RANGE_ORDER } from "../components/chart/chart-resolution";
 
 const EMPTY_MESSAGE = "No data available";
 const EXPECTED_EMPTY = /no data|not found|delisted|unavailable|unsupported/i;
+const TIME_RANGE_INDEX = new Map(TIME_RANGE_ORDER.map((range, index) => [range, index]));
 
 function createBaselineChartRequest(instrument: InstrumentRef): ChartRequest {
   return {
@@ -36,6 +39,27 @@ function createBaselineChartRequest(instrument: InstrumentRef): ChartRequest {
   };
 }
 
+function getChartGranularity(request: ChartRequest): NonNullable<ChartRequest["granularity"]> {
+  return request.granularity ?? "range";
+}
+
+function getTimeRangeIndex(range: ChartRequest["bufferRange"]): number {
+  return TIME_RANGE_INDEX.get(range) ?? 0;
+}
+
+function isSeedableChartRequest(
+  target: ChartRequest,
+  candidate: ChartRequest,
+): boolean {
+  const targetGranularity = getChartGranularity(target);
+  const candidateGranularity = getChartGranularity(candidate);
+  if (targetGranularity !== candidateGranularity) return false;
+  if (targetGranularity === "detail") return false;
+  if (targetGranularity === "resolution" && target.resolution !== candidate.resolution) return false;
+  if (buildInstrumentKey(target.instrument) !== buildInstrumentKey(candidate.instrument)) return false;
+  return getTimeRangeIndex(candidate.bufferRange) <= getTimeRangeIndex(target.bufferRange);
+}
+
 function classifyError(error: unknown): { reasonCode: ProviderReasonCode; message: string } {
   const message = error instanceof Error ? error.message : String(error ?? "");
   if (/timeout/i.test(message)) return { reasonCode: "TIMEOUT", message };
@@ -125,6 +149,7 @@ export class MarketDataCoordinator {
   private version = 0;
   private readonly listeners = new Set<() => void>();
   private readonly inFlight = new Map<string, Promise<unknown>>();
+  private readonly chartRequests = new Map<string, ChartRequest>();
 
   private readonly quoteStore = new QueryStore<Quote>(() => this.bump());
   private readonly snapshotStore = new QueryStore<TickerFinancials>(() => this.bump());
@@ -281,6 +306,49 @@ export class MarketDataCoordinator {
     return promise;
   }
 
+  private findChartSeedEntry(
+    key: string,
+    request: ChartRequest,
+  ): { entry: QueryEntry<PricePoint[]>; data: PricePoint[]; score: number } | null {
+    let best: { entry: QueryEntry<PricePoint[]>; data: PricePoint[]; score: number } | null = null;
+    for (const [candidateKey, candidateRequest] of this.chartRequests) {
+      if (candidateKey === key) continue;
+      if (!isSeedableChartRequest(request, candidateRequest)) continue;
+      const entry = this.chartStore.get(candidateKey);
+      const data = resolveEntryData(entry);
+      if (!data?.length) continue;
+      const score = getTimeRangeIndex(candidateRequest.bufferRange);
+      if (!best || score > best.score) {
+        best = { entry, data, score };
+      }
+    }
+    return best;
+  }
+
+  private createChartLoadingEntry(
+    key: string,
+    request: ChartRequest,
+    current: QueryEntry<PricePoint[]>,
+  ): QueryEntry<PricePoint[]> {
+    if (resolveEntryData(current)?.length) {
+      return loadingEntry(current);
+    }
+
+    const seed = this.findChartSeedEntry(key, request);
+    if (!seed) {
+      return loadingEntry(current);
+    }
+
+    return loadingEntry({
+      ...current,
+      data: seed.data,
+      lastGoodData: seed.entry.lastGoodData?.length ? seed.entry.lastGoodData : seed.data,
+      source: seed.entry.source,
+      fetchedAt: seed.entry.fetchedAt,
+      staleAt: seed.entry.staleAt,
+    });
+  }
+
   async loadSnapshot(
     instrument: InstrumentRef,
     options: { forceRefresh?: boolean } = {},
@@ -379,9 +447,10 @@ export class MarketDataCoordinator {
     options: { forceRefresh?: boolean } = {},
   ): Promise<QueryEntry<PricePoint[]>> {
     const key = buildChartKey(request);
+    this.chartRequests.set(key, request);
     const flightKey = options.forceRefresh ? `${key}|refresh` : key;
     return this.runSingleFlight(flightKey, async () => {
-      this.chartStore.update(key, loadingEntry);
+      this.chartStore.update(key, (current) => this.createChartLoadingEntry(key, request, current));
       const startedAt = Date.now();
       try {
         const data = normalizePriceHistory(

package/src/market-data/hooks.test.tsx

@@ -1,13 +1,16 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useState } from "react";
 import { testRender } from "@opentui/react/test-utils";
-import type { TickerFinancials } from "../types/financials";
+import type { PricePoint, TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "./coordinator";
-import { useFxRatesMap, useTickerFinancialsMap } from "./hooks";
+import { useChartQueries, useFxRatesMap, useTickerFinancialsMap } from "./hooks";
+import type { ChartRequest } from "./request-types";
+import { createIdleEntry } from "./result-types";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 let bumpHarness: (() => void) | null = null;
+let replaceChartRequests: ((requests: readonly ChartRequest[]) => void) | null = null;
 let latestFxRates: Map<string, number> | null = null;
 let latestFinancialsMap: Map<string, TickerFinancials> | null = null;
 
@@ -70,6 +73,31 @@ function HooksHarness() {
   return <text>{String(tick)}</text>;
 }
 
+function ChartQueriesHarness({
+  initialRequests,
+  debounceMs,
+}: {
+  initialRequests: readonly ChartRequest[];
+  debounceMs: number;
+}) {
+  const [requests, setRequests] = useState<readonly ChartRequest[]>(initialRequests);
+  replaceChartRequests = setRequests;
+  useChartQueries(requests, { debounceMs });
+
+  return <text>{String(requests.length)}</text>;
+}
+
+function makeChartRequest(bufferRange: ChartRequest["bufferRange"]): ChartRequest {
+  return {
+    instrument: {
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+    },
+    bufferRange,
+    granularity: "range",
+  };
+}
+
 afterEach(async () => {
   if (testSetup) {
     await act(async () => {
@@ -78,6 +106,7 @@ afterEach(async () => {
     testSetup = undefined;
   }
   bumpHarness = null;
+  replaceChartRequests = null;
   latestFxRates = null;
   latestFinancialsMap = null;
   setSharedMarketDataCoordinator(null);
@@ -117,4 +146,46 @@ describe("market-data hooks", () => {
     expect(latestFxRates).toBe(initialFxRates);
     expect(latestFinancialsMap).toBe(initialFinancialsMap);
   });
+
+  test("debounces chart query batches and cancels superseded schedules", async () => {
+    const loadedRanges: string[] = [];
+    const idleChartEntry = createIdleEntry<PricePoint[]>();
+    const coordinator = {
+      subscribe: () => () => {},
+      getVersion: () => 1,
+      getChartEntry: () => idleChartEntry,
+      loadChart: async (request: ChartRequest) => {
+        loadedRanges.push(request.bufferRange);
+        return idleChartEntry;
+      },
+    };
+    setSharedMarketDataCoordinator(coordinator as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(
+      <ChartQueriesHarness initialRequests={[makeChartRequest("1D")]} debounceMs={40} />,
+      {
+        width: 20,
+        height: 1,
+      },
+    );
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      replaceChartRequests?.([makeChartRequest("1W")]);
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 15));
+      replaceChartRequests?.([makeChartRequest("1M")]);
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 60));
+      await testSetup!.renderOnce();
+    });
+
+    expect(loadedRanges).toEqual(["1M"]);
+  });
 });

package/src/market-data/hooks.tsx

@@ -121,8 +121,12 @@ export function useChartQuery(request: ChartRequest | null | undefined): QueryEn
   return entry;
 }
 
-export function useChartQueries(requests: readonly ChartRequest[]): Map<string, QueryEntry<PricePoint[]>> {
+export function useChartQueries(
+  requests: readonly ChartRequest[],
+  options: { debounceMs?: number } = {},
+): Map<string, QueryEntry<PricePoint[]>> {
   const requestKey = requests.map((request) => buildChartKey(request)).join(",");
+  const debounceMs = Math.max(0, options.debounceMs ?? 0);
   const entries = useCoordinatorSelector((coordinator) => (
     requests.map((request) => [buildChartKey(request), coordinator.getChartEntry(request)] as const)
   ), [] as Array<readonly [string, QueryEntry<PricePoint[]>]>);
@@ -130,10 +134,18 @@ export function useChartQueries(requests: readonly ChartRequest[]): Map<string,
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
     if (!coordinator) return;
-    for (const request of requests) {
-      void coordinator.loadChart(request);
+    const loadRequests = () => {
+      for (const request of requests) {
+        void coordinator.loadChart(request);
+      }
+    };
+    if (debounceMs <= 0) {
+      loadRequests();
+      return;
     }
-  }, [requestKey]);
+    const timeout = setTimeout(loadRequests, debounceMs);
+    return () => clearTimeout(timeout);
+  }, [debounceMs, requestKey]);
 
   return useMemo(() => new Map(entries), [entries]);
 }

package/src/notifications/app-notifier.test.ts

@@ -0,0 +1,177 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildDesktopNotificationCommand,
+  buildSoundCommand,
+  createAppNotifier,
+  createDesktopNotifier,
+} from "./app-notifier";
+
+describe("desktop notification commands", () => {
+  test("builds a macOS notification command", () => {
+    const command = buildDesktopNotificationCommand({
+      title: "Chat mention",
+      body: "@bob mentioned you",
+      subtitle: "#everyone",
+    }, "darwin");
+
+    expect(command).toEqual({
+      command: "osascript",
+      args: ["-e", "display notification \"@bob mentioned you\" with title \"Chat mention\" subtitle \"#everyone\""],
+    });
+  });
+
+  test("builds a Linux notification command", () => {
+    const command = buildDesktopNotificationCommand({
+      title: "Chat mention",
+      body: "@bob mentioned you",
+      subtitle: "#everyone",
+      type: "error",
+    }, "linux");
+
+    expect(command).toEqual({
+      command: "notify-send",
+      args: ["--app-name", "Gloomberb", "--urgency", "critical", "Chat mention", "#everyone\n@bob mentioned you"],
+    });
+  });
+
+  test("builds a Windows notification command", () => {
+    const command = buildDesktopNotificationCommand({
+      title: "Chat mention",
+      body: "@bob mentioned you",
+      subtitle: "#everyone",
+    }, "win32");
+
+    expect(command?.command).toBe("powershell.exe");
+    expect(command?.args[0]).toBe("-NoProfile");
+    expect(command?.args.at(-1)).toContain("$notify.BalloonTipTitle = 'Chat mention';");
+    expect(command?.args.at(-1)).toContain("$notify.BalloonTipText = '#everyone\n@bob mentioned you';");
+  });
+
+  test("adds macOS notification sound when requested", () => {
+    const command = buildDesktopNotificationCommand({
+      title: "Price alert",
+      body: "AAPL triggered",
+      sound: "Glass",
+    }, "darwin");
+
+    expect(command?.args[1]).toContain("sound name \"Glass\"");
+  });
+});
+
+describe("notification sound commands", () => {
+  test("builds platform sound commands", () => {
+    expect(buildSoundCommand("Glass", "darwin")).toEqual({
+      command: "afplay",
+      args: ["/System/Library/Sounds/Glass.aiff"],
+    });
+    expect(buildSoundCommand("Ping", "linux")).toEqual({
+      command: "paplay",
+      args: ["/usr/share/sounds/freedesktop/stereo/message-new-instant.oga"],
+    });
+    expect(buildSoundCommand("Glass", "win32")?.command).toBe("powershell.exe");
+  });
+});
+
+describe("app notifier", () => {
+  test("shows a toast and sends a desktop notification when inactive", () => {
+    const toasts: Array<{ message: string; type?: string; duration?: number }> = [];
+    const desktops: string[] = [];
+    let active = false;
+    const notifier = createAppNotifier({
+      isAppActive: () => active,
+      renderToast: (notification) => {
+        toasts.push({
+          message: notification.body,
+          type: notification.type,
+          duration: notification.duration,
+        });
+      },
+      desktop: {
+        notify(notification) {
+          desktops.push(notification.body);
+        },
+      },
+    });
+
+    notifier.notify({
+      title: "Chat mention",
+      body: "@bob mentioned you",
+      type: "info",
+      desktop: "when-inactive",
+      duration: 5000,
+    });
+
+    expect(toasts).toEqual([{ message: "@bob mentioned you", type: "info", duration: 5000 }]);
+    expect(desktops).toEqual(["@bob mentioned you"]);
+
+    active = true;
+    notifier.notify({
+      body: "Visible toast only",
+      type: "success",
+      desktop: "when-inactive",
+    });
+
+    expect(toasts).toEqual([
+      { message: "@bob mentioned you", type: "info", duration: 5000 },
+      { message: "Visible toast only", type: "success", duration: undefined },
+    ]);
+    expect(desktops).toEqual(["@bob mentioned you"]);
+  });
+
+  test("toast-disabled notifications skip toast delivery", () => {
+    const toasts: string[] = [];
+    const desktops: string[] = [];
+    const notifier = createAppNotifier({
+      isAppActive: () => false,
+      renderToast: (notification) => {
+        toasts.push(notification.body);
+      },
+      desktop: {
+        notify(notification) {
+          desktops.push(notification.body);
+        },
+      },
+    });
+
+    notifier.notify({ body: "Saved", type: "success", toast: false, desktop: "when-inactive" });
+
+    expect(toasts).toEqual([]);
+    expect(desktops).toEqual(["Saved"]);
+  });
+});
+
+describe("desktop notifier", () => {
+  test("stops retrying a missing desktop notification command", () => {
+    const calls: string[] = [];
+    const notifier = createDesktopNotifier({
+      platform: "linux",
+      runner: {
+        run(command, _args, handlers) {
+          calls.push(command);
+          handlers?.onError?.(Object.assign(new Error("missing"), { code: "ENOENT" }));
+        },
+      },
+    });
+
+    notifier.notify({ body: "first" });
+    notifier.notify({ body: "second" });
+
+    expect(calls).toEqual(["notify-send"]);
+  });
+
+  test("plays requested sounds alongside desktop notifications", () => {
+    const calls: string[] = [];
+    const notifier = createDesktopNotifier({
+      platform: "linux",
+      runner: {
+        run(command) {
+          calls.push(command);
+        },
+      },
+    });
+
+    notifier.notify({ body: "AAPL triggered", sound: "Glass" });
+
+    expect(calls).toEqual(["notify-send", "paplay"]);
+  });
+});