gloomberb 0.3.3 → 0.3.7

package/README.md

@@ -25,20 +25,16 @@ For the best experience, use a [Kitty](https://sw.kovidgoyal.net/kitty/)-compati
 ## 🚀 Install
 
 ```bash
-bun install -g gloomberb
-# or
 curl -fsSL gloomberb.com/install | bash
+# or
+bun install -g gloomberb
 ```
 
-Then run `gloomberb` to start.
-
-When developing from source, launch with a real Bun runtime, for example `bun src/index.tsx`.
-If `bun --help` prints Gloomberb help instead of Bun help, your Bun binary has been overwritten and needs to be reinstalled.
-In-app self-updates are disabled while running from source so Gloomberb does not replace the Bun executable.
+Then run `gloomberb`.
 
 ## 🧩 Plugins
 
-Gloomberb has a plugin architecture where everything, from the portfolio list to broker integrations, is a plugin. 
+Everything, from the portfolio list to broker integrations, is a plugin. 
 
 Plugins can add tabs, columns, commands, status bar widgets, and more.
 
@@ -98,3 +94,7 @@ Toggleable plugins can be enabled/disabled from the command bar screen (`Ctrl+p`
 ## License
 
 MIT
+
+## Credits
+
+- [OpenTUI](https://opentui.com/) for the layout

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.3.3",
+  "version": "0.3.7",
   "description": "Bloomberg-style stock portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",

package/src/components/chart/chart-renderer.ts

@@ -917,6 +917,7 @@ export interface RenderChartOptions {
   axisMode?: ChartAxisMode;
   currency?: string;
   colors: ResolvedChartPalette;
+  timeAxisDates?: Array<Date | string | number>;
 }
 
 export interface ChartScene {
@@ -1027,6 +1028,8 @@ export function buildChartScene(
     ? null
     : max - (cursorY / Math.max(chartRows - 1, 1)) * range;
 
+  const timeAxisDates = opts.timeAxisDates ?? points.map((point) => point.date);
+
   return {
     points,
     width: opts.width,
@@ -1045,7 +1048,7 @@ export function buildChartScene(
     dateAtCursor: activePoint.date,
     changeAtCursor: activePoint.close - points[0]!.close,
     changePctAtCursor: points[0]!.close ? ((activePoint.close - points[0]!.close) / points[0]!.close) * 100 : 0,
-    timeLabels: buildTimeAxis(points.map((point) => point.date), opts.width),
+    timeLabels: buildTimeAxis(timeAxisDates, opts.width),
     cursorX,
     cursorY,
     cursorColumn,
@@ -1138,10 +1141,12 @@ export function renderChart(
     );
   }
 
+  const timeAxisDates = opts.timeAxisDates ?? points.map((point) => point.date);
+
   return {
     lines: bufferToBrailleLines(buf, palette.bgColor),
     axisLabels: [...axisLabelsByRow.entries()].map(([row, label]) => ({ row, label })),
-    timeLabels: buildTimeAxis(points.map((point) => point.date), width),
+    timeLabels: buildTimeAxis(timeAxisDates, width),
     activePoint,
     priceAtCursor,
     crosshairPrice,

package/src/components/chart/chart.test.ts

@@ -206,6 +206,32 @@ describe("renderChart", () => {
     expect(buildTimeAxis(yearlyDates, 48)).toBe("2020   2021      2022     2023      2024    2025");
   });
 
+  test("uses source time-axis dates instead of projected extrema dates when provided", () => {
+    const sourceHistory = Array.from({ length: 96 }, (_, index) => ({
+      date: new Date(Date.UTC(2026, 2, 25, index * 3)),
+      close: index % 2 === 0 ? 0.7 + index * 0.001 : 0.3 + index * 0.001,
+      volume: 100 + index,
+    })) as PricePoint[];
+    const sourceDates = sourceHistory.map((point) => point.date);
+    const projection = projectChartData(sourceHistory, 48, "area", true);
+
+    const result = renderChart(projection.points, {
+      width: 48,
+      height: 8,
+      showVolume: false,
+      volumeHeight: 0,
+      cursorX: null,
+      cursorY: null,
+      mode: "area",
+      axisMode: "price",
+      currency: "USD",
+      colors: palette,
+      timeAxisDates: sourceDates,
+    });
+
+    expect(result.timeLabels).toBe(buildTimeAxis(sourceDates, 48));
+  });
+
   test("maps active bucket metadata across all render modes", () => {
     const cases: Array<{ mode: ChartRenderMode; width: number; cursorX: number }> = [
       { mode: "area", width: 12, cursorX: 4 },

package/src/components/chart/stock-chart.tsx

@@ -69,6 +69,8 @@ interface StockChartProps {
   interactive?: boolean;
   compact?: boolean;
   axisMode?: ChartAxisMode;
+  historyOverride?: PricePoint[] | null;
+  currencyOverride?: string | null;
 }
 
 interface DragState {
@@ -505,7 +507,16 @@ function resolveSelectionCursor(
   };
 }
 
-export function StockChart({ width, height, focused, interactive, compact, axisMode = "price" }: StockChartProps) {
+export function StockChart({
+  width,
+  height,
+  focused,
+  interactive,
+  compact,
+  axisMode = "price",
+  historyOverride = null,
+  currencyOverride = null,
+}: StockChartProps) {
   const renderer = useRenderer();
   const { state, dispatch } = useAppState();
   const paneId = usePaneInstanceId();
@@ -637,9 +648,10 @@ export function StockChart({ width, height, focused, interactive, compact, axisM
   const chartWidth = Math.max(width - axisWidth - axisGap, compact ? 12 : 20);
   const maxCursorX = chartWidth - 1;
   const panStep = Math.max(Math.floor(chartWidth / 10), 1);
-  const baseHistory = rangeHistory && rangeHistory.length > 0
-    ? rangeHistory
-    : (financials?.priceHistory ?? []);
+  const baseHistory = historyOverride
+    ?? (rangeHistory && rangeHistory.length > 0
+      ? rangeHistory
+      : (financials?.priceHistory ?? []));
   const detailRequest = useMemo(() => {
     if (compact || !instrumentRef || baseHistory.length < 2 || viewState.zoomLevel <= 1) return null;
     const window = getVisibleWindow(baseHistory, viewState, chartWidth);
@@ -751,11 +763,18 @@ export function StockChart({ width, height, focused, interactive, compact, axisM
     queueMicrotask(() => renderer.requestRender());
   }, [chartHeight, chartWidth, compact, historyRenderKey, renderer, ticker?.metadata.ticker, viewState.renderMode]);
 
-  const chartWindow = useMemo(() => (
-    isDetailView
+  const chartWindow = useMemo(() => {
+    if (historyOverride) {
+      return { points: history, startIdx: 0, endIdx: history.length };
+    }
+    return isDetailView
       ? { points: history, startIdx: 0, endIdx: history.length }
-      : getVisibleWindow(history, viewState, chartWidth)
-  ), [chartWidth, history, isDetailView, viewState.panOffset, viewState.timeRange, viewState.zoomLevel]);
+      : getVisibleWindow(history, viewState, chartWidth);
+  }, [chartWidth, history, historyOverride, isDetailView, viewState.panOffset, viewState.timeRange, viewState.zoomLevel]);
+  const timeAxisDates = useMemo(
+    () => chartWindow.points.map((point) => point.date),
+    [chartWindow.points],
+  );
 
   const projection = useMemo(() => (
     projectChartData(chartWindow.points, chartWidth, viewState.renderMode, !!compact)
@@ -891,7 +910,7 @@ export function StockChart({ width, height, focused, interactive, compact, axisM
       negative: colors.negative,
     }, trend);
   }, [chartWindow.points]);
-  const chartCurrency = financials?.quote?.currency ?? ticker?.metadata.currency ?? "USD";
+  const chartCurrency = currencyOverride ?? financials?.quote?.currency ?? ticker?.metadata.currency ?? "USD";
 
   const cursorX = viewState.cursorX !== null ? clamp(viewState.cursorX, 0, chartWidth - 1) : null;
   const cursorY = viewState.cursorY !== null ? clamp(viewState.cursorY, 0, chartHeight - 1) : null;
@@ -918,7 +937,8 @@ export function StockChart({ width, height, focused, interactive, compact, axisM
     mode: projection.effectiveMode,
     axisMode,
     colors: chartColors,
-  }), [axisMode, chartColors, chartHeight, chartWidth, compact, projection.effectiveMode, projection.points, selectionCursorX, selectionCursorY, showVolume, volumeHeight]);
+    timeAxisDates,
+  }), [axisMode, chartColors, chartHeight, chartWidth, compact, projection.effectiveMode, projection.points, selectionCursorX, selectionCursorY, showVolume, timeAxisDates, volumeHeight]);
   const snappedSelectionCursorX = selectionScene
     ? getPointTerminalColumn(selectionScene.activeIdx, projection.points.length, chartWidth, projection.effectiveMode)
     : null;
@@ -962,7 +982,8 @@ export function StockChart({ width, height, focused, interactive, compact, axisM
     mode: projection.effectiveMode,
     axisMode,
     colors: chartColors,
-  }), [axisMode, chartColors, chartHeight, chartWidth, compact, projection.effectiveMode, projection.points, showVolume, volumeHeight]);
+    timeAxisDates,
+  }), [axisMode, chartColors, chartHeight, chartWidth, compact, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
 
   const rendererState = resolveChartRendererState(preferredRenderer, kittySupport, renderer.resolution);
   const effectiveRenderer: ResolvedChartRenderer = rendererState.renderer;
@@ -978,7 +999,8 @@ export function StockChart({ width, height, focused, interactive, compact, axisM
     axisMode,
     currency: chartCurrency,
     colors: chartColors,
-  }), [axisMode, chartColors, chartCurrency, chartHeight, chartWidth, compact, projection.effectiveMode, projection.points, showVolume, volumeHeight]);
+    timeAxisDates,
+  }), [axisMode, chartColors, chartCurrency, chartHeight, chartWidth, compact, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
 
   const interactiveResult = useMemo(() => (
     effectiveRenderer === "kitty"
@@ -994,8 +1016,9 @@ export function StockChart({ width, height, focused, interactive, compact, axisM
         axisMode,
         currency: chartCurrency,
         colors: chartColors,
+        timeAxisDates,
       })
-  ), [axisMode, chartColors, chartCurrency, chartHeight, chartWidth, compact, displayCursorX, displayCursorY, effectiveRenderer, projection.effectiveMode, projection.points, showVolume, volumeHeight]);
+  ), [axisMode, chartColors, chartCurrency, chartHeight, chartWidth, compact, displayCursorX, displayCursorY, effectiveRenderer, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
 
   const result = effectiveRenderer === "kitty" ? staticResult : interactiveResult!;
 

package/src/plugins/ibkr/gateway-service.test.ts

@@ -6,6 +6,7 @@ import {
   applyTickByTickBidAskToQuote,
   diagnoseLocalIbkrPortIssue,
   IbkrGatewayService,
+  parseIbkrHistoricalBarTime,
   resolveGatewayConnection,
   summarizeBrokerAccount,
 } from "./gateway-service";
@@ -239,6 +240,35 @@ describe("tick-by-tick quote updates", () => {
   });
 });
 
+describe("parseIbkrHistoricalBarTime", () => {
+  test("parses compact day bars without treating them as epoch seconds", () => {
+    const date = parseIbkrHistoricalBarTime(20250328);
+
+    expect(Number.isNaN(date.getTime())).toBe(false);
+    expect(date.getFullYear()).toBe(2025);
+    expect(date.getMonth()).toBe(2);
+    expect(date.getDate()).toBe(28);
+    expect(date.getHours()).toBe(0);
+    expect(date.getMinutes()).toBe(0);
+  });
+
+  test("parses compact intraday bar timestamps", () => {
+    const date = parseIbkrHistoricalBarTime("20250328 09:30:00");
+
+    expect(Number.isNaN(date.getTime())).toBe(false);
+    expect(date.getFullYear()).toBe(2025);
+    expect(date.getMonth()).toBe(2);
+    expect(date.getDate()).toBe(28);
+    expect(date.getHours()).toBe(9);
+    expect(date.getMinutes()).toBe(30);
+    expect(date.getSeconds()).toBe(0);
+  });
+
+  test("preserves epoch-second timestamps for streaming-style bars", () => {
+    expect(parseIbkrHistoricalBarTime(1_700_000_000).getTime()).toBe(1_700_000_000_000);
+  });
+});
+
 describe("diagnoseLocalIbkrPortIssue", () => {
   test("reports a detected local IBKR listener on a different port", async () => {
     const issue = await diagnoseLocalIbkrPortIssue({

package/src/plugins/ibkr/gateway-service.ts

@@ -310,6 +310,42 @@ const GENERIC_BAR_SIZE_MAP: Record<string, BarSizeSetting> = {
   "1w": BarSizeSetting.WEEKS_ONE,
 };
 
+export function parseIbkrHistoricalBarTime(value: string | number): Date {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return new Date(Number.NaN);
+
+    const compactDate = String(Math.trunc(value));
+    if (/^\d{8}$/.test(compactDate)) {
+      return parseIbkrHistoricalBarTime(compactDate);
+    }
+
+    return new Date(value > 10_000_000_000 ? value : value * 1000);
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) return new Date(Number.NaN);
+
+  const parsed = Date.parse(trimmed);
+  if (Number.isFinite(parsed)) {
+    return new Date(parsed);
+  }
+
+  const compactMatch = trimmed.match(/^(\d{4})(\d{2})(\d{2})(?:\D+(\d{2}):(\d{2}):(\d{2}))?/);
+  if (!compactMatch) {
+    return new Date(Number.NaN);
+  }
+
+  const [, yearText, monthText, dayText, hourText, minuteText, secondText] = compactMatch;
+  const year = Number(yearText);
+  const month = Number(monthText) - 1;
+  const day = Number(dayText);
+  const hour = Number(hourText ?? "0");
+  const minute = Number(minuteText ?? "0");
+  const second = Number(secondText ?? "0");
+
+  return new Date(year, month, day, hour, minute, second);
+}
+
 function normalizeQuoteStreamTarget(target: QuoteSubscriptionTarget): QuoteSubscriptionTarget | null {
   const symbol = target.symbol.trim().toUpperCase();
   if (!symbol) return null;
@@ -1006,7 +1042,7 @@ export class IbkrGatewayService {
       const priceDivisor = getIbkrPriceDivisor(contract, details);
 
       return bars.map((bar) => ({
-        date: new Date(typeof bar.time === "number" ? bar.time * 1000 : Date.parse(String(bar.time))),
+        date: parseIbkrHistoricalBarTime(bar.time),
         open: normalizeIbkrPriceValue(bar.open, priceDivisor),
         high: normalizeIbkrPriceValue(bar.high, priceDivisor),
         low: normalizeIbkrPriceValue(bar.low, priceDivisor),
@@ -1064,7 +1100,7 @@ export class IbkrGatewayService {
       const priceDivisor = getIbkrPriceDivisor(contract, details);
 
       return bars.map((bar) => ({
-        date: new Date(typeof bar.time === "number" ? bar.time * 1000 : Date.parse(String(bar.time))),
+        date: parseIbkrHistoricalBarTime(bar.time),
         open: normalizeIbkrPriceValue(bar.open, priceDivisor),
         high: normalizeIbkrPriceValue(bar.high, priceDivisor),
         low: normalizeIbkrPriceValue(bar.low, priceDivisor),

package/src/plugins/prediction-markets/chart.test.tsx

@@ -0,0 +1,139 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { ScrollBoxRenderable } from "@opentui/core";
+import { createTestRenderer } from "@opentui/core/testing";
+import { createRoot } from "@opentui/react";
+import { act, useEffect, useReducer, useRef } from "react";
+import {
+  AppContext,
+  PaneInstanceProvider,
+  appReducer,
+  createInitialState,
+} from "../../state/app-context";
+import { createDefaultConfig } from "../../types/config";
+import { getNativeSurfaceManager } from "../../components/chart/native/surface-manager";
+import { PredictionMarketChart } from "./chart";
+
+const TEST_PANE_ID = "prediction-scroll:test";
+const SURFACE_ID = `chart-surface:${TEST_PANE_ID}:compact:base`;
+
+let testSetup: Awaited<ReturnType<typeof createTestRenderer>> | undefined;
+let root: ReturnType<typeof createRoot> | undefined;
+let scrollBoxRef: ScrollBoxRenderable | null = null;
+const actEnvironment = globalThis as typeof globalThis & {
+  IS_REACT_ACT_ENVIRONMENT?: boolean;
+};
+
+function ChartScrollHarness() {
+  const [state, dispatch] = useReducer(
+    appReducer,
+    (() => {
+      const config = createDefaultConfig("/tmp/gloomberb-test");
+      config.chartPreferences.renderer = "kitty";
+      const initial = createInitialState(config);
+      initial.focusedPaneId = TEST_PANE_ID;
+      return initial;
+    })(),
+  );
+  const scrollRef = useRef<ScrollBoxRenderable>(null);
+
+  useEffect(() => {
+    scrollBoxRef = scrollRef.current;
+  });
+
+  return (
+    <AppContext value={{ state, dispatch }}>
+      <PaneInstanceProvider paneId={TEST_PANE_ID}>
+        <scrollbox ref={scrollRef} height={10} scrollY>
+          <box flexDirection="column">
+            <box height={14}>
+              <text>filler</text>
+            </box>
+            <PredictionMarketChart
+              history={[
+                { date: new Date("2026-04-01T00:00:00Z"), close: 0.45 },
+                { date: new Date("2026-04-02T00:00:00Z"), close: 0.48 },
+                { date: new Date("2026-04-03T00:00:00Z"), close: 0.51 },
+                { date: new Date("2026-04-04T00:00:00Z"), close: 0.49 },
+              ]}
+              width={60}
+              height={12}
+              range="1M"
+              onRangeSelect={() => {}}
+            />
+          </box>
+        </scrollbox>
+      </PaneInstanceProvider>
+    </AppContext>
+  );
+}
+
+async function flushFrames(count = 4) {
+  for (let index = 0; index < count; index += 1) {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+  }
+}
+
+afterEach(() => {
+  scrollBoxRef = null;
+  if (root) {
+    act(() => {
+      root!.unmount();
+    });
+    root = undefined;
+  }
+  if (testSetup) {
+    testSetup.renderer.destroy();
+    testSetup = undefined;
+  }
+  actEnvironment.IS_REACT_ACT_ENVIRONMENT = false;
+});
+
+describe("PredictionMarketChart kitty scrolling", () => {
+  test("creates a native chart surface when scrolled into view", async () => {
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+    testSetup = await createTestRenderer({ width: 100, height: 24 });
+    (testSetup.renderer as { _capabilities: unknown })._capabilities = {
+      kitty_graphics: true,
+    };
+    (testSetup.renderer as { _resolution: unknown })._resolution = {
+      width: 1000,
+      height: 720,
+    };
+
+    root = createRoot(testSetup.renderer);
+    act(() => {
+      root!.render(<ChartScrollHarness />);
+    });
+
+    await flushFrames();
+
+    const manager = getNativeSurfaceManager(testSetup.renderer as never) as unknown as {
+      surfaces: Map<
+        string,
+        {
+          snapshot: {
+            visibleRect: { x: number; y: number; width: number; height: number } | null;
+          };
+        }
+      >;
+    };
+
+    const hiddenSurface = manager.surfaces.get(SURFACE_ID);
+    expect(hiddenSurface).toBeUndefined();
+
+    act(() => {
+      scrollBoxRef!.scrollTop = 14;
+    });
+
+    await flushFrames();
+
+    const visibleSurface = manager.surfaces.get(SURFACE_ID);
+    expect(visibleSurface).toBeDefined();
+    expect(visibleSurface?.snapshot.visibleRect).not.toBeNull();
+    expect(testSetup.captureCharFrame()).toContain("1M");
+  });
+});