gloomberb 0.9.3 → 0.9.4

package/README.md

@@ -60,6 +60,7 @@ Open command mode with `Ctrl+P`, then type a command. Press `` ` `` to open tick
 | `TOP` | Ranked market stories |
 | `MOST` | Market movers |
 | `PF` | Portfolios and watchlists |
+| `KELLY AAPL` | Position sizing |
 | `HELP` | Full in-app shortcut list |
 
 ## What It Does

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",

package/src/app/runtime/desktop-menu.ts

@@ -54,7 +54,11 @@ export function useDesktopApplicationMenuRuntime({
           break;
         case "layout-gridlock": {
           const { width, height } = pluginRegistry.getTermSizeFn();
-          pluginRegistry.updateLayoutFn(gridlockAllPanes(stateRef.current.config.layout, { x: 0, y: 0, width, height }));
+          pluginRegistry.updateLayoutFn(gridlockAllPanes(
+            stateRef.current.config.layout,
+            { x: 0, y: 0, width, height },
+            pluginRegistry.panes,
+          ));
           notifyGridlockComplete(pluginRegistry.notify.bind(pluginRegistry), () => {
             dispatch({ type: "UNDO_LAYOUT" });
           });

package/src/app/runtime/ticker-refresh.ts

@@ -164,7 +164,10 @@ export function useTickerRefreshRuntime({
           dispatch({ type: "SET_REFRESHING", symbol, refreshing: true });
         }
         try {
-          const entries = await marketData.loadSnapshotsBatch(instrumentEntries.map((entry) => entry.instrument));
+          const entries = await marketData.loadSnapshotsBatch(
+            instrumentEntries.map((entry) => entry.instrument),
+            { forceRefresh: true },
+          );
           entries.forEach((entry, index) => {
             const ticker = instrumentEntries[index]?.ticker;
             const data = entry.data ?? entry.lastGoodData;

package/src/app.tsx

@@ -60,7 +60,16 @@ interface AppInnerProps {
 function ThemedAppRoot({ children }: { children: ReactNode }) {
   const themeColors = useThemeColors();
   return (
-    <Box flexDirection="column" flexGrow={1} backgroundColor={themeColors.bg}>
+    <Box
+      flexDirection="column"
+      flexGrow={1}
+      flexShrink={1}
+      flexBasis={0}
+      minWidth={0}
+      minHeight={0}
+      overflow="hidden"
+      backgroundColor={themeColors.bg}
+    >
       {children}
     </Box>
   );

package/src/brokers/account-cache.ts

@@ -124,7 +124,7 @@ export function loadPersistedBrokerAccountMap(
 
   for (const instance of brokerInstances) {
     const broker = brokers.get(instance.brokerType);
-    if (!broker?.listAccounts) continue;
+    if (!broker?.listAccounts && !broker?.importPortfolioSnapshot) continue;
     const accounts = loadPersistedBrokerAccounts(resources, instance, broker);
     if (!accounts || accounts.length === 0) continue;
     accountMap[instance.id] = accounts;

package/src/brokers/sync-broker-instance.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, test } from "bun:test";
 import { createDefaultConfig, type BrokerInstanceConfig } from "../types/config";
 import type { BrokerAdapter } from "../types/broker";
 import type { TickerRecord } from "../types/ticker";
+import { AppPersistence } from "../data/app-persistence";
+import { loadPersistedBrokerAccounts, persistBrokerAccounts } from "./account-cache";
 import {
   restoreBrokerPortfoliosFromTickerPositions,
   syncBrokerInstance,
@@ -164,6 +166,111 @@ describe("syncBrokerInstance", () => {
     ]);
   });
 
+  test("imports account and position data from one broker portfolio snapshot", async () => {
+    const instance = createBrokerInstance();
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-sync-broker-snapshot"),
+      portfolios: [],
+      brokerInstances: [instance],
+    };
+    const tickerRepository = createTickerRepository();
+    const persistence = new AppPersistence(":memory:");
+    let listAccountsCalled = false;
+    let importPositionsCalled = false;
+    const broker: BrokerAdapter = {
+      ...createDemoBroker(),
+      listAccounts: async () => {
+        listAccountsCalled = true;
+        return [];
+      },
+      importPositions: async () => {
+        importPositionsCalled = true;
+        return [];
+      },
+      importPortfolioSnapshot: async () => ({
+        accounts: [{
+          accountId: "ACC-1",
+          name: "Snapshot Account",
+          currency: "USD",
+          netLiquidation: 125_000,
+          grossPositionValue: 175_000,
+          totalCashValue: -50_000,
+        }],
+        positions: [{
+          ticker: "AAPL",
+          exchange: "NASDAQ",
+          shares: 12,
+          avgCost: 180,
+          currency: "USD",
+          accountId: "ACC-1",
+          name: "Apple Inc.",
+          assetCategory: "STK",
+        }],
+      }),
+    };
+
+    try {
+      const result = await syncBrokerInstance({
+        config,
+        instanceId: "demo-broker",
+        brokers: new Map([["demo", broker]]),
+        tickerRepository: tickerRepository as any,
+        resources: persistence.resources,
+      });
+
+      expect(listAccountsCalled).toBe(false);
+      expect(importPositionsCalled).toBe(false);
+      expect(result.brokerAccounts[0]?.netLiquidation).toBe(125_000);
+      expect(result.positions).toHaveLength(1);
+      expect(loadPersistedBrokerAccounts(persistence.resources, instance, broker)).toEqual(result.brokerAccounts);
+    } finally {
+      persistence.close();
+    }
+  });
+
+  test("preserves the last account snapshot when a broker portfolio snapshot fails", async () => {
+    const instance = createBrokerInstance();
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-sync-broker-snapshot-failure"),
+      portfolios: [],
+      brokerInstances: [instance],
+    };
+    const tickerRepository = createTickerRepository();
+    const persistence = new AppPersistence(":memory:");
+    const broker: BrokerAdapter = {
+      ...createDemoBroker(),
+      importPortfolioSnapshot: async () => {
+        throw new Error("account snapshot unavailable");
+      },
+    };
+
+    try {
+      persistBrokerAccounts(persistence.resources, instance, broker, [{
+        accountId: "ACC-1",
+        name: "Stale Account",
+        currency: "USD",
+        netLiquidation: 99_000,
+      }]);
+
+      await expect(syncBrokerInstance({
+        config,
+        instanceId: "demo-broker",
+        brokers: new Map([["demo", broker]]),
+        tickerRepository: tickerRepository as any,
+        resources: persistence.resources,
+      })).rejects.toThrow("account snapshot unavailable");
+
+      expect(loadPersistedBrokerAccounts(persistence.resources, instance, broker)).toEqual([{
+        accountId: "ACC-1",
+        name: "Stale Account",
+        currency: "USD",
+        netLiquidation: 99_000,
+      }]);
+    } finally {
+      persistence.close();
+    }
+  });
+
   test("preserves broker portfolios across sequential profile syncs", async () => {
     const config = {
       ...createDefaultConfig("/tmp/gloomberb-sync-broker-instances"),

package/src/brokers/sync-broker-instance.ts

@@ -131,17 +131,30 @@ export async function syncBrokerInstance({
   const tickers = await loadTickerMap(tickerRepository, existingTickers);
 
   let brokerAccounts: BrokerAccount[] = [];
-  if (broker.listAccounts) {
-    try {
-      brokerAccounts = await broker.listAccounts(instance);
-      if (resources) {
-        try {
-          persistBrokerAccounts(resources, instance, broker, brokerAccounts);
-        } catch {}
+  let positions: BrokerPosition[];
+  if (broker.importPortfolioSnapshot) {
+    const snapshot = await broker.importPortfolioSnapshot(instance);
+    brokerAccounts = snapshot.accounts;
+    positions = snapshot.positions;
+    if (resources) {
+      try {
+        persistBrokerAccounts(resources, instance, broker, brokerAccounts);
+      } catch {}
+    }
+  } else {
+    if (broker.listAccounts) {
+      try {
+        brokerAccounts = await broker.listAccounts(instance);
+        if (resources) {
+          try {
+            persistBrokerAccounts(resources, instance, broker, brokerAccounts);
+          } catch {}
+        }
+      } catch (error) {
+        throw error;
       }
-    } catch {
-      brokerAccounts = [];
     }
+    positions = await broker.importPositions(instance);
   }
 
   const accountMetadata = new Map(
@@ -154,7 +167,6 @@ export async function syncBrokerInstance({
     ]),
   );
 
-  const positions = await broker.importPositions(instance);
   const syncedAt = Date.now();
 
   let nextConfig = config;

package/src/cli/desktop-pane-shot.ts

@@ -3,7 +3,7 @@ import { tmpdir } from "os";
 import { join } from "path";
 import { pathToFileURL } from "url";
 import type { AppConfig } from "../types/config";
-import type { TickerFinancials } from "../types/financials";
+import type { OptionsChain, TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
 import type { PaneRuntimeState } from "../core/state/app/state";
 import {
@@ -20,6 +20,7 @@ export interface DesktopPaneShotPayload {
   heightPx: number;
   tickers: TickerRecord[];
   financials: Array<[string, TickerFinancials]>;
+  optionsChains: Array<[string, OptionsChain]>;
   paneState: Record<string, PaneRuntimeState>;
 }
 

package/src/cli/pane-functions/screenshot.ts

@@ -1,7 +1,7 @@
 import { dirname, resolve } from "path";
 import { mkdir } from "fs/promises";
 import type { PaneRuntimeState } from "../../core/state/app/state";
-import type { TickerFinancials } from "../../types/financials";
+import type { OptionsChain, TickerFinancials } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
 import { slugifyName } from "../../utils/slugify";
 import { renderDesktopPaneScreenshot, type DesktopPaneShotPayload } from "../desktop-pane-shot";
@@ -18,6 +18,7 @@ import {
 
 const DESKTOP_CELL_WIDTH_PX = 8;
 const DESKTOP_CELL_HEIGHT_PX = 18;
+const OPTIONS_PANE_ID = "options";
 
 export function defaultScreenshotPath(resolved: ResolvedPaneFunction, rawArg: string): string {
   const suffix = slugifyName([resolved.token, rawArg].filter(Boolean).join("-"), "pane");
@@ -70,11 +71,21 @@ async function buildDesktopShotPayload(
 
   const tickers: TickerRecord[] = [];
   const financials: Array<[string, TickerFinancials]> = [];
+  const optionsChains: Array<[string, OptionsChain]> = [];
+  const includeOptionsChains = resolved.pane.id === OPTIONS_PANE_ID || resolved.template?.paneId === OPTIONS_PANE_ID;
   for (const symbol of collectShotSymbols(resolved, rawArg)) {
     const entry = await fetchTickerFinancials(context, symbol);
     const data = await withShotPriceHistory(context, symbol, entry.tickerFile, entry.financials);
     tickers.push(entry.tickerFile ?? createFallbackTicker(symbol, data, context));
     financials.push([symbol, data]);
+    if (includeOptionsChains && context.dataProvider.getOptionsChain) {
+      const exchange = entry.tickerFile?.metadata.exchange
+        ?? data.quote?.listingExchangeName
+        ?? data.quote?.exchangeName
+        ?? "";
+      const chain = await context.dataProvider.getOptionsChain(symbol, exchange);
+      optionsChains.push([symbol, chain]);
+    }
   }
 
   return {
@@ -86,6 +97,7 @@ async function buildDesktopShotPayload(
     heightPx,
     tickers,
     financials,
+    optionsChains,
     paneState,
   };
 }

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

@@ -1,5 +1,13 @@
 import { describe, expect, test } from "bun:test";
-import { buildBarChartScene, renderBarChart, renderNativeBarChart } from "./bar-chart-renderer";
+import {
+  buildBarChartScene,
+  renderBarChart,
+  renderBarChartAxis,
+  renderBarChartYAxis,
+  renderNativeBarChart,
+  resolveNativeBarPixelBounds,
+  resolveBarChartHover,
+} from "./bar-chart-renderer";
 
 const series = [
   {
@@ -27,27 +35,124 @@ describe("bar chart renderer", () => {
     const scene = buildBarChartScene(series, {
       width: 24,
       height: 8,
-      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666" },
+      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666", negativeColor: "#ff5555" },
     });
 
     expect(scene).not.toBeNull();
     expect(scene!.categories).toEqual(["2024", "2025"]);
     expect(scene!.bars).toHaveLength(4);
     expect(scene!.zeroRow).toBeGreaterThanOrEqual(0);
+    expect(scene!.bars.find((bar) => bar.value < 0)?.color).toBe("#ff5555");
   });
 
   test("renders text fallback and native bitmap output", () => {
     const scene = buildBarChartScene(series, {
       width: 24,
       height: 8,
-      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666" },
+      colors: {
+        bgColor: "#000000",
+        gridColor: "#333333",
+        axisColor: "#666666",
+        negativeColor: "#ff5555",
+        hoverColor: "#ffffff",
+      },
     })!;
 
     expect(renderBarChart(scene).join("\n")).toContain("█");
 
     const bitmap = renderNativeBarChart(scene, 96, 48);
+    const negativePixel = Array.from({ length: bitmap.pixels.length / 4 }).some((_, pixelIndex) => {
+      const index = pixelIndex * 4;
+      return bitmap.pixels[index]! > 200 && bitmap.pixels[index + 1]! < 100 && bitmap.pixels[index + 2]! < 100;
+    });
     expect(bitmap.width).toBe(96);
     expect(bitmap.height).toBe(48);
     expect(bitmap.pixels.some((value) => value > 0)).toBe(true);
+    expect(negativePixel).toBe(true);
+
+    const hover = resolveBarChartHover(scene, scene.bars[0]!.x);
+    expect(renderBarChart(scene, hover).join("\n")).toContain("▓");
+    const hoverBitmap = renderNativeBarChart(scene, 96, 48, hover);
+    const hoverPixel = Array.from({ length: hoverBitmap.pixels.length / 4 }).some((_, pixelIndex) => {
+      const index = pixelIndex * 4;
+      return hoverBitmap.pixels[index]! > 240 && hoverBitmap.pixels[index + 1]! > 240 && hoverBitmap.pixels[index + 2]! > 240;
+    });
+    expect(hoverBitmap.pixels).not.toEqual(bitmap.pixels);
+    expect(hoverPixel).toBe(true);
+  });
+
+  test("renders y-axis labels and resolves hover targets", () => {
+    const scene = buildBarChartScene(series, {
+      width: 24,
+      height: 8,
+      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666" },
+    })!;
+
+    const yAxis = renderBarChartYAxis(scene, 8, (value) => String(Math.round(value)));
+    const labelCount = yAxis.filter((line) => line.trim().length > 0).length;
+    expect(labelCount).toBeGreaterThanOrEqual(5);
+    expect(yAxis.join("\n")).toContain("22");
+    expect(yAxis.join("\n")).toContain("0");
+
+    const hover = resolveBarChartHover(scene, scene.bars[1]!.x);
+    expect(hover).toMatchObject({
+      seriesId: "NVDA",
+      seriesLabel: "NVDA",
+      category: "2024",
+      value: 20,
+      x: scene.bars[1]!.x,
+      width: scene.bars[1]!.width,
+      row: scene.bars[1]!.row,
+    });
+  });
+
+  test("renders dense single-series bars with consistent separators and readable x-axis labels", () => {
+    const denseSeries = [{
+      id: "value",
+      label: "Value",
+      color: "#00ff66",
+      points: Array.from({ length: 14 }, (_unused, index) => ({
+        category: `${2015 + index} Q1`,
+        value: index + 1,
+      })),
+    }];
+    const scene = buildBarChartScene(denseSeries, {
+      width: 47,
+      height: 8,
+      colors: { bgColor: "#000000", gridColor: "#333333", axisColor: "#666666", negativeColor: "#ff5555" },
+    })!;
+
+    const lastBar = scene.bars.at(-1)!;
+    expect(lastBar.x + lastBar.width).toBe(scene.width);
+    expect(renderBarChart(scene)[scene.zeroRow]).not.toContain("─");
+
+    const bitmapWidth = 470;
+    const pixelBounds = scene.bars.map((bar) => resolveNativeBarPixelBounds(scene, bar, bitmapWidth));
+    const pixelWidths = pixelBounds.map((bounds) => bounds.rightExclusive - bounds.left);
+    expect(Math.max(...pixelWidths) - Math.min(...pixelWidths)).toBeLessThanOrEqual(1);
+    expect(pixelBounds[0]!.left).toBe(0);
+    expect(pixelBounds.at(-1)!.rightExclusive).toBe(bitmapWidth);
+    const pixelGaps: number[] = [];
+    for (let index = 1; index < pixelBounds.length; index++) {
+      pixelGaps.push(pixelBounds[index]!.left - pixelBounds[index - 1]!.rightExclusive);
+    }
+    expect(new Set(pixelGaps)).toEqual(new Set([1]));
+
+    const bitmap = renderNativeBarChart(scene, bitmapWidth, 80);
+    const zeroY = Math.round((scene.zeroRow / Math.max(scene.height - 1, 1)) * (bitmap.height - 1));
+    let separatorColumns = 0;
+    for (let x = 0; x < bitmap.width; x++) {
+      const index = (zeroY * bitmap.width + x) * 4;
+      if (bitmap.pixels[index + 1]! <= 120) separatorColumns++;
+    }
+    expect(separatorColumns).toBe(scene.categories.length - 1);
+
+    const axis = renderBarChartAxis(scene, 1);
+    expect(axis).toHaveLength(1);
+    expect(axis.every((line) => line.length === scene.width)).toBe(true);
+    expect(axis.join("\n")).toContain("2015");
+    expect(axis.join("\n")).not.toContain("Q1");
+    expect(axis.join("\n")).not.toContain("20 20");
+    expect(axis[0]!.endsWith("  ")).toBe(true);
   });
 });