gloomberb 0.3.7 → 0.4.0

package/src/components/ticker-list-table.tsx

@@ -1,4 +1,4 @@
-import { useRef, type RefObject } from "react";
+import { memo, useRef, type RefObject } from "react";
 import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core";
 import { EmptyState } from "./ui";
 import { colors, hoverBg } from "../theme/colors";
@@ -13,6 +13,11 @@ export interface TickerTableCell {
 }
 
 export type QuoteFlashDirection = "up" | "down" | "flat";
+type ResolveTickerTableCell = (
+  column: ColumnConfig,
+  ticker: TickerRecord,
+  financials: TickerFinancials | undefined,
+) => TickerTableCell;
 
 const FLASHABLE_QUOTE_COLUMN_IDS = new Set([
   "price",
@@ -39,6 +44,153 @@ function resolveQuoteFlashColor(direction: QuoteFlashDirection, fallbackColor: s
   }
 }
 
+interface TickerListTableProps {
+  columns: ColumnConfig[];
+  tickers: TickerRecord[];
+  cursorSymbol: string | null;
+  hoveredIdx: number | null;
+  setHoveredIdx: (index: number | null) => void;
+  setCursorSymbol: (symbol: string) => void;
+  resolveCell: ResolveTickerTableCell;
+  financialsMap: Map<string, TickerFinancials>;
+  headerScrollRef?: RefObject<ScrollBoxRenderable | null>;
+  scrollRef?: RefObject<ScrollBoxRenderable | null>;
+  syncHeaderScroll?: () => void;
+  onBodyScrollActivity?: () => void;
+  flashSymbols?: Map<string, QuoteFlashDirection>;
+  sortColumnId?: string | null;
+  sortDirection?: "asc" | "desc";
+  onHeaderClick?: (columnId: string) => void;
+  onRowActivate?: (ticker: TickerRecord) => void;
+  emptyTitle?: string;
+  emptyHint?: string;
+}
+
+const TickerListHeader = memo(function TickerListHeader({
+  columns,
+  headerScrollRef,
+  sortColumnId,
+  sortDirection,
+  onHeaderClick,
+}: {
+  columns: ColumnConfig[];
+  headerScrollRef?: RefObject<ScrollBoxRenderable | null>;
+  sortColumnId?: string | null;
+  sortDirection?: "asc" | "desc";
+  onHeaderClick?: (columnId: string) => void;
+}) {
+  return (
+    <scrollbox
+      ref={headerScrollRef}
+      height={1}
+      scrollX
+      focusable={false}
+    >
+      <box flexDirection="row" height={1} paddingX={1}>
+        {columns.map((column) => {
+          const isSorted = sortColumnId === column.id;
+          const indicator = isSorted ? (sortDirection === "asc" ? " \u25B2" : " \u25BC") : "";
+          const labelText = column.label + indicator;
+          return (
+            <box
+              key={column.id}
+              width={column.width + 1}
+              onMouseDown={onHeaderClick ? (event) => {
+                event.preventDefault();
+                onHeaderClick(column.id);
+              } : undefined}
+            >
+              <text attributes={TextAttributes.BOLD} fg={isSorted ? colors.text : colors.textDim}>
+                {padTo(labelText, column.width, column.align)}
+              </text>
+            </box>
+          );
+        })}
+      </box>
+    </scrollbox>
+  );
+});
+
+const TickerListRow = memo(function TickerListRow({
+  columns,
+  ticker,
+  index,
+  isSelected,
+  isHovered,
+  financials,
+  flashDirection,
+  setHoveredIdx,
+  setCursorSymbol,
+  resolveCell,
+  onRowActivate,
+}: {
+  columns: ColumnConfig[];
+  ticker: TickerRecord;
+  index: number;
+  isSelected: boolean;
+  isHovered: boolean;
+  financials: TickerFinancials | undefined;
+  flashDirection: QuoteFlashDirection | undefined;
+  setHoveredIdx: (index: number | null) => void;
+  setCursorSymbol: (symbol: string) => void;
+  resolveCell: ResolveTickerTableCell;
+  onRowActivate?: (ticker: TickerRecord) => void;
+}) {
+  const lastActivatedAtRef = useRef<number | null>(null);
+  const rowBg = isSelected ? colors.selected : isHovered ? hoverBg() : colors.bg;
+
+  return (
+    <box
+      flexDirection="row"
+      height={1}
+      paddingX={1}
+      backgroundColor={rowBg}
+      onMouseMove={() => setHoveredIdx(index)}
+      onMouseDown={(event) => {
+        event.preventDefault();
+        setCursorSymbol(ticker.metadata.ticker);
+        if (!onRowActivate) return;
+        const now = Date.now();
+        if (lastActivatedAtRef.current != null && now - lastActivatedAtRef.current <= 350) {
+          lastActivatedAtRef.current = null;
+          onRowActivate(ticker);
+          return;
+        }
+        lastActivatedAtRef.current = now;
+      }}
+    >
+      {columns.map((column) => {
+        const { text, color } = resolveCell(column, ticker, financials);
+        const baseFg = color || (isSelected ? colors.selectedText : colors.text);
+        const shouldFlash = flashDirection != null && FLASHABLE_QUOTE_COLUMN_IDS.has(column.id);
+        const cellFg = shouldFlash
+          ? resolveQuoteFlashColor(flashDirection, baseFg)
+          : baseFg;
+
+        return (
+          <box key={column.id} width={column.width + 1}>
+            <text fg={cellFg}>
+              {padTo(text, column.width, column.align)}
+            </text>
+          </box>
+        );
+      })}
+    </box>
+  );
+}, (previous, next) => (
+  previous.columns === next.columns
+  && previous.ticker === next.ticker
+  && previous.index === next.index
+  && previous.isSelected === next.isSelected
+  && previous.isHovered === next.isHovered
+  && previous.financials === next.financials
+  && previous.flashDirection === next.flashDirection
+  && previous.setHoveredIdx === next.setHoveredIdx
+  && previous.setCursorSymbol === next.setCursorSymbol
+  && previous.resolveCell === next.resolveCell
+  && previous.onRowActivate === next.onRowActivate
+));
+
 export function TickerListTable({
   columns,
   tickers,
@@ -59,60 +211,18 @@ export function TickerListTable({
   onRowActivate,
   emptyTitle = "No tickers.",
   emptyHint = "Press Ctrl+P to add one.",
-}: {
-  columns: ColumnConfig[];
-  tickers: TickerRecord[];
-  cursorSymbol: string | null;
-  hoveredIdx: number | null;
-  setHoveredIdx: (index: number | null) => void;
-  setCursorSymbol: (symbol: string) => void;
-  resolveCell: (column: ColumnConfig, ticker: TickerRecord, financials: TickerFinancials | undefined) => TickerTableCell;
-  financialsMap: Map<string, TickerFinancials>;
-  headerScrollRef?: RefObject<ScrollBoxRenderable | null>;
-  scrollRef?: RefObject<ScrollBoxRenderable | null>;
-  syncHeaderScroll?: () => void;
-  onBodyScrollActivity?: () => void;
-  flashSymbols?: Map<string, QuoteFlashDirection>;
-  sortColumnId?: string | null;
-  sortDirection?: "asc" | "desc";
-  onHeaderClick?: (columnId: string) => void;
-  onRowActivate?: (ticker: TickerRecord) => void;
-  emptyTitle?: string;
-  emptyHint?: string;
-}) {
+}: TickerListTableProps) {
   const safeFlashSymbols = flashSymbols ?? new Map<string, QuoteFlashDirection>();
-  const lastActivatedRef = useRef<{ symbol: string; at: number } | null>(null);
 
   return (
     <>
-      <scrollbox
-        ref={headerScrollRef}
-        height={1}
-        scrollX
-        focusable={false}
-      >
-        <box flexDirection="row" height={1} paddingX={1}>
-          {columns.map((column) => {
-            const isSorted = sortColumnId === column.id;
-            const indicator = isSorted ? (sortDirection === "asc" ? " \u25B2" : " \u25BC") : "";
-            const labelText = column.label + indicator;
-            return (
-              <box
-                key={column.id}
-                width={column.width + 1}
-                onMouseDown={onHeaderClick ? (event) => {
-                  event.preventDefault();
-                  onHeaderClick(column.id);
-                } : undefined}
-              >
-                <text attributes={TextAttributes.BOLD} fg={isSorted ? colors.text : colors.textDim}>
-                  {padTo(labelText, column.width, column.align)}
-                </text>
-              </box>
-            );
-          })}
-        </box>
-      </scrollbox>
+      <TickerListHeader
+        columns={columns}
+        headerScrollRef={headerScrollRef}
+        sortColumnId={sortColumnId}
+        sortDirection={sortDirection}
+        onHeaderClick={onHeaderClick}
+      />
 
       <scrollbox
         ref={scrollRef}
@@ -131,54 +241,21 @@ export function TickerListTable({
           </box>
         ) : (
           tickers.map((ticker, index) => {
-            const isSelected = ticker.metadata.ticker === cursorSymbol;
-            const isHovered = index === hoveredIdx && !isSelected;
-            const financials = financialsMap.get(ticker.metadata.ticker);
-            const rowBg = isSelected ? colors.selected : isHovered ? hoverBg() : colors.bg;
-            const flashDirection = safeFlashSymbols.get(ticker.metadata.ticker);
-
             return (
-              <box
+              <TickerListRow
                 key={ticker.metadata.ticker}
-                flexDirection="row"
-                height={1}
-                paddingX={1}
-                backgroundColor={rowBg}
-                onMouseMove={() => setHoveredIdx(index)}
-                onMouseDown={(event) => {
-                  event.preventDefault();
-                  setCursorSymbol(ticker.metadata.ticker);
-                  if (!onRowActivate) return;
-                  const now = Date.now();
-                  const last = lastActivatedRef.current;
-                  if (last?.symbol === ticker.metadata.ticker && now - last.at <= 350) {
-                    lastActivatedRef.current = null;
-                    onRowActivate(ticker);
-                    return;
-                  }
-                  lastActivatedRef.current = {
-                    symbol: ticker.metadata.ticker,
-                    at: now,
-                  };
-                }}
-              >
-                {columns.map((column) => {
-                  const { text, color } = resolveCell(column, ticker, financials);
-                  const baseFg = color || (isSelected ? colors.selectedText : colors.text);
-                  const shouldFlash = flashDirection != null && FLASHABLE_QUOTE_COLUMN_IDS.has(column.id);
-                  const cellFg = shouldFlash
-                    ? resolveQuoteFlashColor(flashDirection, baseFg)
-                    : baseFg;
-
-                  return (
-                    <box key={column.id} width={column.width + 1}>
-                      <text fg={cellFg}>
-                        {padTo(text, column.width, column.align)}
-                      </text>
-                    </box>
-                  );
-                })}
-              </box>
+                columns={columns}
+                ticker={ticker}
+                index={index}
+                isSelected={ticker.metadata.ticker === cursorSymbol}
+                isHovered={index === hoveredIdx && ticker.metadata.ticker !== cursorSymbol}
+                financials={financialsMap.get(ticker.metadata.ticker)}
+                flashDirection={safeFlashSymbols.get(ticker.metadata.ticker)}
+                setHoveredIdx={setHoveredIdx}
+                setCursorSymbol={setCursorSymbol}
+                resolveCell={resolveCell}
+                onRowActivate={onRowActivate}
+              />
             );
           })
         )}

package/src/components/ui/data-table.tsx

@@ -3,6 +3,7 @@ import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core";
 import { colors, hoverBg } from "../../theme/colors";
 import type { ColumnConfig } from "../../types/config";
 import { padTo } from "../../utils/format";
+import { useDoubleClickActivation } from "../use-double-click-activation";
 import { EmptyState } from "./status";
 
 export type DataTableColumn = Pick<
@@ -34,6 +35,7 @@ export interface DataTableProps<
   getItemKey: (item: T, index: number) => string;
   isSelected: (item: T, index: number) => boolean;
   onSelect: (item: T, index: number) => void;
+  onActivate?: (item: T, index: number) => void;
   renderCell: (
     item: T,
     column: C,
@@ -46,6 +48,11 @@ export interface DataTableProps<
   overscan?: number;
 }
 
+interface DataTableRowPointerTarget<T> {
+  item: T;
+  index: number;
+}
+
 export function DataTable<T, C extends DataTableColumn = DataTableColumn>({
   columns,
   items,
@@ -61,6 +68,7 @@ export function DataTable<T, C extends DataTableColumn = DataTableColumn>({
   getItemKey,
   isSelected,
   onSelect,
+  onActivate,
   renderCell,
   emptyStateTitle,
   emptyStateHint,
@@ -80,6 +88,17 @@ export function DataTable<T, C extends DataTableColumn = DataTableColumn>({
     () => items.slice(startIndex, endIndex),
     [endIndex, items, scrollVersion, startIndex],
   );
+  const handleRowMouseDown =
+    useDoubleClickActivation<DataTableRowPointerTarget<T>>({
+      onSelect: ({ item, index }) => {
+        onSelect(item, index);
+      },
+      onActivate: onActivate
+        ? ({ item, index }) => {
+            onActivate(item, index);
+          }
+        : undefined,
+    });
 
   const handleBodyScrollActivity = () => {
     if (virtualize) {
@@ -163,7 +182,10 @@ export function DataTable<T, C extends DataTableColumn = DataTableColumn>({
                   onMouseMove={() => setHoveredIdx(index)}
                   onMouseDown={(event) => {
                     event.preventDefault();
-                    onSelect(item, index);
+                    handleRowMouseDown(getItemKey(item, index), {
+                      item,
+                      index,
+                    });
                   }}
                 >
                   {columns.map((column) => {
@@ -182,7 +204,10 @@ export function DataTable<T, C extends DataTableColumn = DataTableColumn>({
                           }
                           event.preventDefault();
                           event.stopPropagation?.();
-                          onSelect(item, index);
+                          handleRowMouseDown(getItemKey(item, index), {
+                            item,
+                            index,
+                          });
                         }}
                       >
                         <text

package/src/components/ui/index.ts

@@ -43,6 +43,7 @@ export { Section, FieldRow, DialogFrame } from "./frame";
 export type { SectionProps, FieldRowProps, DialogFrameProps } from "./frame";
 
 export { ExternalLink, openUrl } from "./external-link";
+export { PageStackView } from "./page-stack-view";
 
 export { Spinner, ProgressBar, SkeletonRow, LoadingBlock } from "./loading";
 export type {

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" };