gloomberb 0.3.7 → 0.4.1

package/src/components/ui/page-stack-view.tsx

@@ -0,0 +1,60 @@
+import { useKeyboard } from "@opentui/react";
+import type { ReactNode } from "react";
+import { colors } from "../../theme/colors";
+import { isBackNavigationKey } from "../../utils/back-navigation";
+
+interface PageStackViewProps {
+  focused: boolean;
+  detailOpen: boolean;
+  onBack: () => void;
+  rootContent: ReactNode;
+  detailContent: ReactNode;
+  backLabel?: string;
+  backHint?: string;
+}
+
+export function PageStackView({
+  focused,
+  detailOpen,
+  onBack,
+  rootContent,
+  detailContent,
+  backLabel = "Back",
+  backHint,
+}: PageStackViewProps) {
+  useKeyboard((event) => {
+    if (!focused || !detailOpen || !isBackNavigationKey(event)) return;
+    event.stopPropagation?.();
+    event.preventDefault?.();
+    onBack();
+  });
+
+  if (!detailOpen) {
+    return (
+      <box flexDirection="column" flexGrow={1}>
+        {rootContent}
+      </box>
+    );
+  }
+
+  return (
+    <box flexDirection="column" flexGrow={1}>
+      <box height={1} flexDirection="row">
+        <box
+          onMouseDown={(event) => {
+            event.preventDefault?.();
+            event.stopPropagation?.();
+            onBack();
+          }}
+        >
+          <text fg={colors.textBright}>{`<- ${backLabel}`}</text>
+        </box>
+        <box flexGrow={1} />
+        {backHint ? <text fg={colors.textMuted}>{backHint}</text> : null}
+      </box>
+      <box flexDirection="column" flexGrow={1}>
+        {detailContent}
+      </box>
+    </box>
+  );
+}

package/src/components/use-double-click-activation.ts

@@ -0,0 +1,31 @@
+import { useCallback, useRef } from "react";
+
+interface LastClickState {
+  targetKey: string;
+}
+
+export function useDoubleClickActivation<T>({
+  onSelect,
+  onActivate,
+}: {
+  onSelect?: (value: T) => void;
+  onActivate?: (value: T) => void;
+}) {
+  const lastClickRef = useRef<LastClickState | null>(null);
+
+  return useCallback((targetKey: string, value: T) => {
+    const lastClick = lastClickRef.current;
+
+    onSelect?.(value);
+
+    if (lastClick && lastClick.targetKey === targetKey) {
+      lastClickRef.current = null;
+      onActivate?.(value);
+      return;
+    }
+
+    lastClickRef.current = {
+      targetKey,
+    };
+  }, [onActivate, onSelect]);
+}

package/src/index.tsx

@@ -4,10 +4,9 @@ import { App } from "./app";
 import { getDataDir, initDataDir } from "./data/config-store";
 import { join } from "path";
 import { existsSync, mkdirSync } from "fs";
-import { runCli } from "./cli/index";
+import { dispatchCli } from "./cli/index";
 import { loadExternalPlugins } from "./plugins/loader";
 import { debugLog } from "./utils/debug-log";
-import { parsePredictionLaunchArgs } from "./plugins/prediction-markets/launch";
 
 async function main() {
   // Intercept console.log/warn/error to capture in debug log
@@ -18,10 +17,14 @@ async function main() {
 
   // Handle CLI subcommands (install, remove, update, plugins)
   const cliArgs = process.argv.slice(2);
-  const predictionLaunchIntent = parsePredictionLaunchArgs(cliArgs);
-  if (cliArgs.length > 0 && !predictionLaunchIntent) {
-    const handled = await runCli(cliArgs);
-    if (handled) return;
+  const externalPlugins = await loadExternalPlugins();
+  let cliLaunchRequest = null;
+  if (cliArgs.length > 0) {
+    const dispatchResult = await dispatchCli(cliArgs, { externalPlugins });
+    if (dispatchResult.kind === "handled") return;
+    if (dispatchResult.kind === "launch-ui") {
+      cliLaunchRequest = dispatchResult.request;
+    }
   }
 
   // Determine data directory
@@ -40,9 +43,6 @@ async function main() {
   // Load or create config
   const config = await initDataDir(dataDir);
 
-  // Load external plugins from ~/.gloomberb/plugins/
-  const externalPlugins = await loadExternalPlugins();
-
   // Create renderer
   const renderer = await createCliRenderer({
     exitOnCtrlC: true,
@@ -56,7 +56,7 @@ async function main() {
       config={config}
       renderer={renderer}
       externalPlugins={externalPlugins}
-      predictionLaunchIntent={predictionLaunchIntent}
+      cliLaunchRequest={cliLaunchRequest}
     />
   );
 }

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

@@ -80,8 +80,8 @@ describe("MarketDataCoordinator", () => {
     const coordinator = new MarketDataCoordinator(provider);
     const request = {
       instrument: { symbol: "AAPL", exchange: "NASDAQ" },
-      range: "1Y" as const,
-      granularity: "daily" as const,
+      bufferRange: "1Y" as const,
+      granularity: "range" as const,
     };
 
     const first = await coordinator.loadChart(request);
@@ -103,8 +103,8 @@ describe("MarketDataCoordinator", () => {
     const coordinator = new MarketDataCoordinator(provider);
     const request = {
       instrument: { symbol: "AAPL", exchange: "NASDAQ" },
-      range: "1Y" as const,
-      granularity: "daily" as const,
+      bufferRange: "1Y" as const,
+      granularity: "range" as const,
     };
 
     const entry = await coordinator.loadChart(request);
@@ -142,6 +142,30 @@ describe("MarketDataCoordinator", () => {
     expect(coordinator.getQuoteEntry(instrument).data?.price).toBe(412.5);
   });
 
+  it("routes manual-resolution chart requests through the resolution-aware provider path", async () => {
+    let requested: { range: string; resolution: string } | null = null;
+    const provider = createProvider({
+      getPriceHistoryForResolution: async (_symbol, _exchange, range, resolution) => {
+        requested = { range, resolution };
+        return [
+          { date: new Date("2024-01-01"), close: 100 },
+          { date: new Date("2024-01-02"), close: 101 },
+        ];
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+
+    const entry = await coordinator.loadChart({
+      instrument: { symbol: "AAPL", exchange: "NASDAQ" },
+      bufferRange: "1Y",
+      granularity: "resolution",
+      resolution: "1d",
+    });
+
+    expect(requested).toEqual({ range: "1Y", resolution: "1d" });
+    expect(entry.data?.length).toBe(2);
+  });
+
   it("projects live quote updates into premarket display fields when the stream lacks explicit ext-hours fields", async () => {
     let streamed: ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null = null;
     const provider = createProvider({
@@ -192,6 +216,7 @@ describe("MarketDataCoordinator", () => {
         change: 2.5,
         changePercent: 2.48,
         lastUpdated: Date.now(),
+        dataSource: "live",
       },
     );
 
@@ -287,6 +312,69 @@ describe("MarketDataCoordinator", () => {
     expect(coordinator.getTickerFinancialsSync(instrument)?.quote?.price).toBe(0.245);
   });
 
+  it("keeps the fresh snapshot quote when a stale cloud stream update arrives later", async () => {
+    const fixedNow = Date.parse("2026-04-08T10:30:00Z");
+    const realDateNow = Date.now;
+    Date.now = () => fixedNow;
+    try {
+      let streamed: ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null = null;
+      const provider = createProvider({
+        getTickerFinancials: async () => ({
+          quote: {
+            symbol: "HY9H",
+            providerId: "yahoo",
+            dataSource: "yahoo",
+            price: 598,
+            currency: "EUR",
+            change: 6,
+            changePercent: 1.01,
+            lastUpdated: Date.parse("2026-04-08T10:25:00Z"),
+            listingExchangeName: "FWB2",
+            marketState: "REGULAR",
+            sessionConfidence: "derived",
+          },
+          annualStatements: [],
+          quarterlyStatements: [],
+          priceHistory: [],
+        }),
+        subscribeQuotes: (_targets, onQuote) => {
+          streamed = onQuote as typeof streamed;
+          return () => {};
+        },
+      });
+      const coordinator = new MarketDataCoordinator(provider);
+      const instrument = { symbol: "HY9H", exchange: "FWB2" };
+
+      await coordinator.loadSnapshot(instrument);
+      coordinator.subscribeQuotes([{ instrument }]);
+      const onStreamed = streamed;
+      if (!onStreamed) throw new Error("expected streaming callback");
+      onStreamed(
+        { symbol: "HY9H", exchange: "FWB2" },
+        {
+          symbol: "HY9H",
+          providerId: "gloomberb-cloud",
+          dataSource: "delayed",
+          price: 528,
+          currency: "EUR",
+          change: 4,
+          changePercent: 0.76,
+          lastUpdated: Date.parse("2026-04-07T17:55:00Z"),
+          listingExchangeName: "FWB2",
+          marketState: "REGULAR",
+          sessionConfidence: "explicit",
+        },
+      );
+
+      expect(coordinator.getQuoteEntry(instrument).data).toBeNull();
+      expect(coordinator.getQuoteEntry(instrument).lastGoodData?.price).toBe(598);
+      expect(coordinator.getTickerFinancialsSync(instrument)?.quote?.price).toBe(598);
+      expect(coordinator.getTickerFinancialsSync(instrument)?.quote?.providerId).toBe("yahoo");
+    } finally {
+      Date.now = realDateNow;
+    }
+  });
+
   it("hydrates ticker financials synchronously from primed cached data", () => {
     const coordinator = new MarketDataCoordinator(createProvider());
     const instrument = { symbol: "AAPL", exchange: "NASDAQ" };

package/src/market-data/coordinator.ts

@@ -23,6 +23,7 @@ import {
 } from "./selectors";
 import { traceMarketData } from "./trace";
 import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../utils/price-history";
+import { hasFreshQuoteForCurrentSession, isQuoteStaleForCurrentSession } from "../utils/quote-freshness";
 
 const EMPTY_MESSAGE = "No data available";
 const EXPECTED_EMPTY = /no data|not found|delisted|unavailable|unsupported/i;
@@ -30,8 +31,8 @@ const EXPECTED_EMPTY = /no data|not found|delisted|unavailable|unsupported/i;
 function createBaselineChartRequest(instrument: InstrumentRef): ChartRequest {
   return {
     instrument,
-    range: "5Y",
-    granularity: "daily",
+    bufferRange: "5Y",
+    granularity: "range",
   };
 }
 
@@ -92,6 +93,21 @@ function readyEntry<T>(
   };
 }
 
+function readyQuoteEntry(
+  current: QueryEntry<Quote>,
+  quote: Quote,
+  source: string,
+  attempts: ProviderAttempt[],
+): QueryEntry<Quote> {
+  if (
+    isQuoteStaleForCurrentSession(quote)
+    && hasFreshQuoteForCurrentSession([current.data, current.lastGoodData])
+  ) {
+    return readyEntry(current, null, current.source ?? source, attempts, { keepLastGoodOnEmpty: true });
+  }
+  return readyEntry(current, quote, source, attempts, { keepLastGoodOnEmpty: true });
+}
+
 function errorEntry<T>(current: QueryEntry<T>, attempt: ProviderAttempt): QueryEntry<T> {
   return {
     ...current,
@@ -349,7 +365,7 @@ export class MarketDataCoordinator {
         );
         const source = quote.providerId ?? this.dataProvider.id;
         const attempts = [createAttempt(source, startedAt, "success")];
-        return this.quoteStore.update(key, (current) => readyEntry(current, quote, source, attempts, { keepLastGoodOnEmpty: true }));
+        return this.quoteStore.update(key, (current) => readyQuoteEntry(current, quote, source, attempts));
       } catch (error) {
         const classified = classifyError(error);
         const attempt = createAttempt(this.dataProvider.id, startedAt, EXPECTED_EMPTY.test(classified.message) ? "empty" : "fatal_error", classified.reasonCode, classified.message);
@@ -381,10 +397,21 @@ export class MarketDataCoordinator {
                 cacheMode: options.forceRefresh ? "refresh" : "default",
               },
             )
+            : request.granularity === "resolution" && request.resolution && this.dataProvider.getPriceHistoryForResolution
+              ? await this.dataProvider.getPriceHistoryForResolution(
+                request.instrument.symbol,
+                request.instrument.exchange ?? "",
+                request.bufferRange,
+                request.resolution,
+                {
+                  ...toMarketDataContext(request.instrument),
+                  cacheMode: options.forceRefresh ? "refresh" : "default",
+                },
+              )
             : await this.dataProvider.getPriceHistory(
               request.instrument.symbol,
               request.instrument.exchange ?? "",
-              request.range,
+              request.bufferRange,
               {
                 ...toMarketDataContext(request.instrument),
                 cacheMode: options.forceRefresh ? "refresh" : "default",
@@ -555,7 +582,7 @@ export class MarketDataCoordinator {
       const key = buildQuoteKey(instrument);
       const current = this.quoteStore.get(key);
       const attempts = [createAttempt(quote.providerId ?? this.dataProvider.id, Date.now(), "success")];
-      this.quoteStore.set(key, readyEntry(current, quote, quote.providerId ?? this.dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
+      this.quoteStore.set(key, readyQuoteEntry(current, quote, quote.providerId ?? this.dataProvider.id, attempts));
     });
   }
 }

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

@@ -0,0 +1,120 @@
+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 { TickerRecord } from "../types/ticker";
+import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "./coordinator";
+import { useFxRatesMap, useTickerFinancialsMap } from "./hooks";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let bumpHarness: (() => void) | null = null;
+let latestFxRates: Map<string, number> | null = null;
+let latestFinancialsMap: Map<string, TickerFinancials> | null = null;
+
+const readyUsdEntry = {
+  phase: "ready" as const,
+  data: 1,
+  lastGoodData: 1,
+  source: "test",
+  fetchedAt: 1,
+  staleAt: null,
+  error: null,
+  attempts: [],
+};
+const readyEurEntry = {
+  phase: "ready" as const,
+  data: 1.08,
+  lastGoodData: 1.08,
+  source: "test",
+  fetchedAt: 1,
+  staleAt: null,
+  error: null,
+  attempts: [],
+};
+const sampleFinancials: TickerFinancials = {
+  annualStatements: [],
+  quarterlyStatements: [],
+  priceHistory: [],
+  quote: {
+    symbol: "SAP",
+    price: 250,
+    currency: "EUR",
+    change: 2,
+    changePercent: 0.8,
+    lastUpdated: 1,
+  },
+};
+const tickers: TickerRecord[] = [
+  {
+    metadata: {
+      ticker: "SAP",
+      exchange: "XETRA",
+      currency: "EUR",
+      name: "SAP",
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  },
+];
+
+function HooksHarness() {
+  const [tick, setTick] = useState(0);
+  bumpHarness = () => setTick((current) => current + 1);
+
+  latestFxRates = useFxRatesMap(["USD", "EUR"]);
+  latestFinancialsMap = useTickerFinancialsMap(tickers);
+
+  return <text>{String(tick)}</text>;
+}
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => {
+      testSetup!.renderer.destroy();
+    });
+    testSetup = undefined;
+  }
+  bumpHarness = null;
+  latestFxRates = null;
+  latestFinancialsMap = null;
+  setSharedMarketDataCoordinator(null);
+});
+
+describe("market-data hooks", () => {
+  test("preserve derived map instances across unrelated rerenders", async () => {
+    const coordinator = {
+      subscribe: () => () => {},
+      getVersion: () => 1,
+      getFxEntry: (currency: string) => (currency === "EUR" ? readyEurEntry : readyUsdEntry),
+      loadFxRate: async () => {},
+      getTickerFinancialsSync: () => sampleFinancials,
+    };
+    setSharedMarketDataCoordinator(coordinator as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(<HooksHarness />, {
+      width: 20,
+      height: 1,
+    });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    const initialFxRates = latestFxRates;
+    const initialFinancialsMap = latestFinancialsMap;
+
+    await act(async () => {
+      bumpHarness?.();
+      await Promise.resolve();
+    });
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    expect(latestFxRates).toBe(initialFxRates);
+    expect(latestFinancialsMap).toBe(initialFinancialsMap);
+  });
+});

package/src/market-data/hooks.tsx

@@ -9,6 +9,7 @@ import {
   resolveEntryValue,
 } from "./coordinator";
 import type { QueryEntry } from "./result-types";
+import { buildChartKey } from "./selectors";
 
 function useCoordinatorVersion(): number {
   const coordinator = getSharedMarketDataCoordinator();
@@ -33,6 +34,21 @@ function stableCurrencyList(currencies: Array<string | null | undefined>): strin
   )].sort((left, right) => left.localeCompare(right));
 }
 
+function buildTickerFinancialsMapKey(tickers: TickerRecord[]): string {
+  return tickers.map((ticker) => {
+    const instrument = ticker.metadata.broker_contracts?.[0];
+    return [
+      ticker.metadata.ticker,
+      ticker.metadata.exchange ?? "",
+      instrument?.brokerId ?? "",
+      instrument?.brokerInstanceId ?? "",
+      instrument?.conId ?? "",
+      instrument?.localSymbol ?? "",
+      instrument?.symbol ?? "",
+    ].join("|");
+  }).join("::");
+}
+
 export function useTickerInstrument(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): InstrumentRef | null {
   return useMemo(() => instrumentFromTicker(ticker, symbol ?? null), [symbol, ticker]);
 }
@@ -54,7 +70,12 @@ export function useTickerFinancials(symbol: string | null | undefined, ticker: T
 }
 
 export function useTickerFinancialsMap(tickers: TickerRecord[]): Map<string, TickerFinancials> {
-  return useCoordinatorSelector((coordinator) => {
+  const coordinator = getSharedMarketDataCoordinator();
+  const version = useCoordinatorVersion();
+  const tickerKey = buildTickerFinancialsMapKey(tickers);
+
+  return useMemo(() => {
+    if (!coordinator) return new Map<string, TickerFinancials>();
     const result = new Map<string, TickerFinancials>();
     for (const ticker of tickers) {
       const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
@@ -65,7 +86,7 @@ export function useTickerFinancialsMap(tickers: TickerRecord[]): Map<string, Tic
       }
     }
     return result;
-  }, new Map<string, TickerFinancials>());
+  }, [coordinator, tickerKey, version]);
 }
 
 export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): QueryEntry<Quote> | null {
@@ -85,15 +106,7 @@ export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerR
 }
 
 export function useChartQuery(request: ChartRequest | null | undefined): QueryEntry<PricePoint[]> | null {
-  const key = request ? [
-    request.instrument.symbol,
-    request.instrument.exchange ?? "",
-    request.range,
-    request.granularity ?? "daily",
-    request.startDate?.toISOString() ?? "",
-    request.endDate?.toISOString() ?? "",
-    request.barSize ?? "",
-  ].join("|") : null;
+  const key = request ? buildChartKey(request) : null;
   const entry = useCoordinatorSelector(
     (coordinator) => (request ? coordinator.getChartEntry(request) : null),
     null,
@@ -108,6 +121,23 @@ export function useChartQuery(request: ChartRequest | null | undefined): QueryEn
   return entry;
 }
 
+export function useChartQueries(requests: readonly ChartRequest[]): Map<string, QueryEntry<PricePoint[]>> {
+  const requestKey = requests.map((request) => buildChartKey(request)).join(",");
+  const entries = useCoordinatorSelector((coordinator) => (
+    requests.map((request) => [buildChartKey(request), coordinator.getChartEntry(request)] as const)
+  ), [] as Array<readonly [string, QueryEntry<PricePoint[]>]>);
+
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator) return;
+    for (const request of requests) {
+      void coordinator.loadChart(request);
+    }
+  }, [requestKey]);
+
+  return useMemo(() => new Map(entries), [entries]);
+}
+
 export function useNewsQuery(request: NewsRequest | null | undefined): QueryEntry<NewsItem[]> | null {
   const key = request ? `${request.instrument.symbol}|${request.instrument.exchange ?? ""}|${request.count ?? 50}` : null;
   const entry = useCoordinatorSelector(
@@ -203,10 +233,17 @@ export function useFxRate(currency: string | null | undefined): QueryEntry<numbe
 }
 
 export function useFxRatesMap(currencies: Array<string | null | undefined>): Map<string, number> {
-  const normalizedCurrencies = useMemo(() => stableCurrencyList(currencies), [currencies]);
-  const entries = useCoordinatorSelector((coordinator) => (
-    normalizedCurrencies.map((currency) => [currency, coordinator.getFxEntry(currency)] as const)
-  ), [] as Array<readonly [string, QueryEntry<number>]>);
+  const coordinator = getSharedMarketDataCoordinator();
+  const version = useCoordinatorVersion();
+  const normalizedCurrencyKey = stableCurrencyList(currencies).join("|");
+  const normalizedCurrencies = useMemo(
+    () => (normalizedCurrencyKey ? normalizedCurrencyKey.split("|") : []),
+    [normalizedCurrencyKey],
+  );
+  const entries = useMemo(() => {
+    if (!coordinator) return [] as Array<readonly [string, QueryEntry<number>]>;
+    return normalizedCurrencies.map((currency) => [currency, coordinator.getFxEntry(currency)] as const);
+  }, [coordinator, normalizedCurrencies, version]);
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
@@ -214,7 +251,7 @@ export function useFxRatesMap(currencies: Array<string | null | undefined>): Map
     for (const currency of normalizedCurrencies) {
       void coordinator.loadFxRate(currency);
     }
-  }, [normalizedCurrencies.join("|")]);
+  }, [normalizedCurrencyKey]);
 
   return useMemo(() => {
     const rates = new Map<string, number>();

package/src/market-data/request-types.ts

@@ -1,4 +1,5 @@
 import type { TimeRange } from "../components/chart/chart-types";
+import type { ManualChartResolution } from "../components/chart/chart-resolution";
 import type { QuoteSubscriptionTarget } from "../types/data-provider";
 import type { BrokerContractRef } from "../types/instrument";
 import type { TickerRecord } from "../types/ticker";
@@ -11,12 +12,13 @@ export interface InstrumentRef {
   instrument?: BrokerContractRef | null;
 }
 
-export type ChartGranularity = "daily" | "detail";
+export type ChartGranularity = "range" | "detail" | "resolution";
 
 export interface ChartRequest {
   instrument: InstrumentRef;
-  range: TimeRange;
+  bufferRange: TimeRange;
   granularity?: ChartGranularity;
+  resolution?: ManualChartResolution;
   startDate?: Date;
   endDate?: Date;
   barSize?: string;