gloomberb 0.9.3 → 0.9.4

package/src/components/ui/tabs.tsx

@@ -31,6 +31,7 @@ export interface TabsProps {
   focused?: boolean;
   keyboardNavigation?: boolean;
   scrollable?: boolean;
+  scrollId?: string;
 }
 
 const WHEEL_DELTA_PER_CELL = 8;
@@ -47,6 +48,7 @@ export function Tabs({
   focused = false,
   keyboardNavigation = true,
   scrollable = true,
+  scrollId,
 }: TabsProps) {
   const ui = useUiHost();
   const NativeTabs = ui.Tabs;
@@ -57,11 +59,11 @@ export function Tabs({
     navigationValueRef.current = activeValue;
   }
   const palette = {
-    activeFg: variant === "bare" ? colors.textBright : colors.text,
+    activeFg: focused || variant === "bare" ? colors.textBright : colors.text,
     inactiveFg: colors.textDim,
     disabledFg: colors.textMuted,
     hoverFg: colors.text,
-    activeUnderline: colors.borderFocused,
+    activeUnderline: focused ? colors.textBright : colors.borderFocused,
     inactiveUnderline: colors.bg,
     hoverUnderline: colors.border,
     hoverBg: hoverBg(),
@@ -118,6 +120,7 @@ export function Tabs({
         closeMode={closeMode}
         addLabel={addLabel}
         onAdd={onAdd}
+        focused={focused}
         palette={palette}
       />
     );
@@ -133,7 +136,9 @@ export function Tabs({
       closeMode={closeMode}
       addLabel={addLabel}
       onAdd={onAdd}
+      focused={focused}
       scrollable={scrollable}
+      scrollId={scrollId}
       palette={palette}
     />
   );
@@ -157,7 +162,9 @@ function OpenTuiTabs({
   closeMode = "always",
   addLabel = "+",
   onAdd,
+  focused = false,
   scrollable = true,
+  scrollId,
   palette,
 }: TabsProps & {
   palette: {
@@ -187,7 +194,7 @@ function OpenTuiTabs({
   useEffect(() => {
     const scrollBox = scrollRef.current;
     const activeIndex = tabs.findIndex((tab) => tab.value === activeValue);
-    const viewportWidth = scrollBox?.viewport?.width ?? 0;
+    const viewportWidth = scrollBox?.viewport?.width || scrollBox?.width || 0;
     if (!scrollBox || activeIndex < 0 || viewportWidth <= 0) return;
 
     const activeLeft = tabWidths.slice(0, activeIndex).reduce((sum, width) => sum + width, 0);
@@ -195,14 +202,15 @@ function OpenTuiTabs({
     const currentLeft = scrollBox.scrollLeft ?? 0;
     const currentRight = currentLeft + viewportWidth;
     const maxScrollLeft = Math.max(0, totalWidth - viewportWidth);
+    const scrollToLeft = (left: number) => {
+      scrollBox.scrollLeft = left;
+      scrollBox.scrollTo({ x: left, y: scrollBox.scrollTop });
+    };
 
     if (activeLeft < currentLeft) {
-      scrollBox.scrollTo({ x: activeLeft, y: scrollBox.scrollTop });
+      scrollToLeft(activeLeft);
     } else if (activeRight > currentRight) {
-      scrollBox.scrollTo({
-        x: Math.min(activeRight - viewportWidth, maxScrollLeft),
-        y: scrollBox.scrollTop,
-      });
+      scrollToLeft(Math.min(activeRight - viewportWidth, maxScrollLeft));
     }
   }, [activeValue, tabWidths, tabs, totalWidth]);
 
@@ -214,7 +222,7 @@ function OpenTuiTabs({
     const direction = event?.scroll?.direction;
     if (!direction) return;
     const scrollBox = scrollRef.current;
-    const viewportWidth = scrollBox?.viewport?.width ?? 0;
+    const viewportWidth = scrollBox?.viewport?.width || scrollBox?.width || 0;
     if (!scrollBox || viewportWidth <= 0 || totalWidth <= viewportWidth) return;
 
     event.preventDefault?.();
@@ -228,6 +236,7 @@ function OpenTuiTabs({
       0,
       Math.min(maxScrollLeft, (scrollBox.scrollLeft ?? 0) + directionSign * deltaCells),
     );
+    scrollBox.scrollLeft = nextLeft;
     scrollBox.scrollTo({ x: nextLeft, y: scrollBox.scrollTop });
   };
 
@@ -236,10 +245,16 @@ function OpenTuiTabs({
       {tabs.map((tab, index) => {
         const active = tab.value === activeValue;
         const hovered = hoveredValue === tab.value && !tab.disabled;
+        const focusedActive = focused && active;
         const tabWidth = tabWidths[index] ?? tab.label.length + 2;
         const showClose = !!tab.onClose && (closeMode === "always" || active);
         const attributes = (active ? TextAttributes.BOLD : 0)
-          | (variant === "underline" && !compact && (active || hovered) ? TextAttributes.UNDERLINE : 0);
+          | (
+            (variant === "underline" && !compact && (active || hovered))
+              || (variant === "bare" && focusedActive)
+              ? TextAttributes.UNDERLINE
+              : 0
+          );
         const startHover = tab.disabled
           ? undefined
           : () => {
@@ -323,6 +338,7 @@ function OpenTuiTabs({
 
   return (
     <ScrollBox
+      id={scrollId}
       ref={scrollRef}
       width="100%"
       height={1}

package/src/components/ui/ui.test.tsx

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useEffect, useRef, useState } from "react";
 import { TestDialogProvider, testRender } from "../../renderers/opentui/test-utils";
+import { TextAttributes } from "../../ui";
 import type { BoxRenderable, ScrollBoxRenderable } from "@opentui/core";
 import { ChoiceDialog } from "./choice-dialog";
 import { DataTable, type DataTableColumn } from "./data-table";
@@ -128,12 +129,18 @@ function DataTableHorizontalScrollHarness({
   containerWidth = 32,
   containerHeight = 5,
   rowCount = 1,
+  columnGap,
+  horizontalPadding,
+  fillAvailableWidth,
   showHorizontalScrollbar,
 }: {
   columns?: DataTableColumn[];
   containerWidth?: number;
   containerHeight?: number;
   rowCount?: number;
+  columnGap?: number;
+  horizontalPadding?: number;
+  fillAvailableWidth?: boolean;
   showHorizontalScrollbar?: boolean;
 }) {
   const headerScrollRef = useRef<ScrollBoxRenderable>(null);
@@ -162,11 +169,45 @@ function DataTableHorizontalScrollHarness({
       getItemKey={(row) => row.id}
       renderCell={(row) => ({ text: row.name })}
       emptyStateTitle="No rows."
+      columnGap={columnGap}
+      horizontalPadding={horizontalPadding}
+      fillAvailableWidth={fillAvailableWidth}
       showHorizontalScrollbar={showHorizontalScrollbar}
     />
   );
 }
 
+function DataTableColumnGapHarness() {
+  const headerScrollRef = useRef<ScrollBoxRenderable>(null);
+  const scrollRef = useRef<ScrollBoxRenderable>(null);
+  const items = [{ id: "row-0", left: "AA", right: "BB" }];
+
+  return (
+    <DataTableView
+      rootWidth={8}
+      rootHeight={4}
+      selection={{ kind: "none" }}
+      columns={[
+        { id: "left", label: "L", width: 2, align: "left" },
+        { id: "right", label: "R", width: 2, align: "left" },
+      ]}
+      items={items}
+      sortColumnId={null}
+      sortDirection="asc"
+      onHeaderClick={() => {}}
+      headerScrollRef={headerScrollRef}
+      scrollRef={scrollRef}
+      getItemKey={(row) => row.id}
+      renderCell={(row, column) => ({ text: column.id === "left" ? row.left : row.right })}
+      emptyStateTitle="No rows."
+      columnGap={0}
+      horizontalPadding={0}
+      fillAvailableWidth={false}
+      showHorizontalScrollbar={false}
+    />
+  );
+}
+
 function DataTableVirtualizationHarness() {
   const headerScrollRef = useRef<ScrollBoxRenderable>(null);
   const scrollRef = useRef<ScrollBoxRenderable>(null);
@@ -360,6 +401,31 @@ describe("shared UI kit", () => {
     expect(lastSelected).toBe("chart");
   });
 
+  test("marks the active bare tab when it has keyboard focus", async () => {
+    testSetup = await testRender(
+      <Tabs
+        tabs={[
+          { label: "One", value: "one" },
+          { label: "Two", value: "two" },
+        ]}
+        activeValue="one"
+        onSelect={() => {}}
+        variant="bare"
+        compact
+        focused
+      />,
+      { width: 24, height: 2 },
+    );
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    const activeSpan = testSetup.captureSpans().lines[0]?.spans.find((span) => span.text.includes("One"));
+    expect(activeSpan).toBeDefined();
+    expect((activeSpan!.attributes & TextAttributes.UNDERLINE)).toBe(TextAttributes.UNDERLINE);
+  });
+
   test("selects tabs by clicking their text labels", async () => {
     let lastSelected = "overview";
     const selectedValues: string[] = [];
@@ -737,6 +803,27 @@ describe("shared UI kit", () => {
     expect(tableScrollBoxForTest?.horizontalScrollBar.visible).toBe(false);
   });
 
+  test("renders data table columns without spacer cells when column gap is zero", async () => {
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
+    testSetup = await testRender(
+      <AppContext value={{ state, dispatch: () => {} }}>
+        <PaneInstanceProvider paneId="portfolio-list:main">
+          <DataTableColumnGapHarness />
+        </PaneInstanceProvider>
+      </AppContext>,
+      { width: 8, height: 4 },
+    );
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("AABB");
+    expect(frame).not.toContain("AA BB");
+  });
+
   test("hides data table horizontal scrolling when content fits", async () => {
     const state = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
     tableScrollBoxForTest = null;

package/src/core/state/app/layout-reducer.ts

@@ -1,4 +1,4 @@
-import { cloneLayout, DEFAULT_LAYOUT, type SavedLayout } from "../../../types/config";
+import { cloneLayout, createBlankLayout, type SavedLayout } from "../../../types/config";
 import {
   clonePaneStateMap,
   cloneSavedLayout,
@@ -96,7 +96,7 @@ export function reduceLayoutAction(state: AppState, action: AppAction): AppState
       );
       const newLayout: SavedLayout = {
         name: action.name,
-        layout: cloneLayout(DEFAULT_LAYOUT),
+        layout: createBlankLayout(),
         paneState: {},
       };
       const layouts = [...currentConfig.layouts, newLayout];

package/src/plugins/builtin/analytics/index.test.tsx

@@ -293,12 +293,14 @@ describe("PortfolioAnalyticsPane", () => {
               currency: "USD",
               source: "flex",
               updatedAt: new Date(2026, 2, 27).getTime(),
+              asOfDate: "2026-03-26",
               totalCashValue: -50000,
               settledCash: -45000,
               availableFunds: 15000,
               excessLiquidity: 12000,
               buyingPower: 30000,
               netLiquidation: 125000,
+              grossPositionValue: 113636,
               dailyPnl: 900,
               unrealizedPnl: 777,
               realizedPnl: -25,
@@ -318,6 +320,8 @@ describe("PortfolioAnalyticsPane", () => {
 
     const frame = testSetup!.captureCharFrame();
     expect(frame).toContain("Net Liq       125k");
+    expect(frame).toContain("Val           113.6k");
+    expect(frame).toContain("Margin Lev    1.1x");
     expect(frame).toContain("Cash          -50k");
     expect(frame).toContain("Day           +900");
     expect(frame).toContain("P&L           +777");
@@ -326,8 +330,8 @@ describe("PortfolioAnalyticsPane", () => {
     expect(frame).toContain("Avail         15k");
     expect(frame).toContain("Excess        12k");
     expect(frame).toContain("BP            30k");
-    expect(frame).toContain("Synced        just now");
-    expect(frame).toContain("Source        Flex Mar 27");
+    expect(frame).toContain("As Of         Mar 26");
+    expect(frame).toContain("Source        Flex Mar 26");
   });
 
   test("falls back from a Gateway portfolio to a configured Flex profile for IBKR history", async () => {

package/src/plugins/builtin/analytics/pane-model.ts

@@ -7,7 +7,7 @@ import { formatCompact, formatNumber, formatPercentRaw } from "../../../utils/fo
 import { formatRelativeAge } from "../../../utils/relative-time";
 import { instrumentFromTicker, type ChartRequest } from "../../../market-data/request-types";
 import { buildChartKey } from "../../../market-data/selectors";
-import { resolvePortfolioAccountMetrics } from "../portfolio-list/account-metrics";
+import { resolvePortfolioAccountMetrics, resolvePortfolioMarketValue } from "../portfolio-list/account-metrics";
 import type { ColumnContext, PortfolioSummaryTotals } from "../portfolio-list/metrics";
 import type { ResolvedPortfolioAccountState } from "../portfolio-list/summary";
 import { performancePointValue } from "./broker-performance";
@@ -38,6 +38,31 @@ export type ChartEntryLookup = Map<string, {
   lastGoodData?: PricePoint[] | null;
 } | undefined>;
 
+function formatIsoDateMonthDay(value: string): string {
+  const match = value.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) return value;
+  const [, year, month, day] = match;
+  return new Date(Number(year), Number(month) - 1, Number(day)).toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+  });
+}
+
+function formatAccountFreshness(account: ResolvedPortfolioAccountState["account"] | undefined): string | null {
+  if (!account) return null;
+  if (account.asOfDate) return formatIsoDateMonthDay(account.asOfDate);
+  return account.updatedAt ? formatRelativeAge(account.updatedAt) : null;
+}
+
+function finiteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function formatMarginLeverage(netLiquidation: number | undefined, totalMarketValue: number): string | null {
+  if (!finiteNumber(netLiquidation) || !finiteNumber(totalMarketValue) || totalMarketValue <= 0) return null;
+  return `${(netLiquidation / totalMarketValue).toFixed(1)}x`;
+}
+
 export function buildPortfolioChartTargets(portfolioTickers: TickerRecord[]): PortfolioChartTarget[] {
   return portfolioTickers.flatMap((ticker) => {
     const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
@@ -96,7 +121,6 @@ export function buildBenchmarkReturnSeries(
 
 export function buildAnalyticsSummaryRows({
   accountState,
-  activePortfolio,
   brokerPerformance,
   portfolioStats,
 }: {
@@ -108,7 +132,8 @@ export function buildAnalyticsSummaryRows({
   const rows: AnalyticsMetricRow[] = [];
   const account = accountState?.account;
   const accountMetrics = resolvePortfolioAccountMetrics(portfolioStats, account);
-  const syncedAt = activePortfolio?.lastSyncedAt ?? account?.updatedAt;
+  const accountFreshness = formatAccountFreshness(account);
+  const totalMarketValue = resolvePortfolioMarketValue(portfolioStats, account);
 
   if (account?.netLiquidation != null) {
     rows.push({
@@ -122,10 +147,20 @@ export function buildAnalyticsSummaryRows({
   rows.push({
     id: "total-value",
     label: "Val",
-    value: formatCompact(portfolioStats.totalMktValue),
+    value: formatCompact(totalMarketValue),
     color: colors.text,
   });
 
+  const marginLeverage = formatMarginLeverage(account?.netLiquidation, totalMarketValue);
+  if (marginLeverage) {
+    rows.push({
+      id: "margin-leverage",
+      label: "Margin Lev",
+      value: marginLeverage,
+      color: colors.text,
+    });
+  }
+
   if (account?.totalCashValue != null) {
     rows.push({
       id: "cash",
@@ -202,11 +237,11 @@ export function buildAnalyticsSummaryRows({
     });
   }
   if (accountState) {
-    if (syncedAt) {
+    if (accountFreshness) {
       rows.push({
-        id: "last-sync",
-        label: "Synced",
-        value: formatRelativeAge(syncedAt),
+        id: "account-freshness",
+        label: "As Of",
+        value: accountFreshness,
         color: colors.textDim,
       });
     }

package/src/plugins/builtin/kelly-sizer/constants.ts

@@ -0,0 +1,3 @@
+export const KELLY_PANE_ID = "kelly-sizer";
+export const COMMON_ASSUMPTIONS_STATE_KEY = "commonAssumptions:v1";
+export const DEFAULT_FLOATING_SIZE = { width: 88, height: 30 };

package/src/plugins/builtin/kelly-sizer/fields.ts

@@ -0,0 +1,214 @@
+import {
+  type KellyCommonAssumptions,
+  type KellySizerDraft,
+  type KellySizerModeDrafts,
+  type KellySizingMode,
+  type ScenarioKellyAssumptions,
+} from "./model";
+
+export interface InlineField {
+  id: string;
+  label: string;
+  value?: number;
+  valueText?: string;
+  percent?: boolean;
+  suffix?: string;
+  allowNegative?: boolean;
+  onValue?: (value: number) => void;
+  onClear?: () => void;
+  onPress?: () => void;
+  tone?: "neutral" | "positive" | "negative";
+}
+
+export function buildModeFields({
+  mode,
+  draft,
+  updateDraft,
+}: {
+  mode: KellySizingMode;
+  draft: KellySizerDraft;
+  updateDraft: (patch: Partial<KellySizerDraft>) => void;
+}): InlineField[] {
+  if (mode === "scenario") {
+    const scenario = draft as ScenarioKellyAssumptions;
+    const updateOutcome = (index: number, patch: Partial<ScenarioKellyAssumptions["outcomes"][number]>) => {
+      updateDraft({
+        outcomes: scenario.outcomes.map((outcome, outcomeIndex) => (
+          outcomeIndex === index ? { ...outcome, ...patch } : outcome
+        )),
+      } as Partial<KellySizerDraft>);
+    };
+    return scenario.outcomes.flatMap((outcome, index): InlineField[] => [
+      {
+        id: `${outcome.id}:p`,
+        label: `${outcome.label} p`,
+        value: outcome.probability,
+        percent: true,
+        onValue: (value) => updateOutcome(index, { probability: value }),
+      },
+      {
+        id: `${outcome.id}:ret`,
+        label: `${outcome.label} ret`,
+        value: outcome.returnPct,
+        percent: true,
+        allowNegative: true,
+        tone: outcome.returnPct >= 0 ? "positive" : "negative",
+        onValue: (value) => updateOutcome(index, { returnPct: value }),
+      },
+    ]);
+  }
+
+  if (mode === "risk-budget") {
+    const risk = draft as KellySizerModeDrafts["risk-budget"];
+    return [
+      {
+        id: "riskBudget",
+        label: "Risk budget",
+        value: risk.riskBudgetFraction,
+        percent: true,
+        onValue: (value) => updateDraft({ riskBudgetFraction: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "downside",
+        label: "Downside",
+        value: risk.downsideReturn,
+        percent: true,
+        allowNegative: true,
+        tone: "negative",
+        onValue: (value) => updateDraft({ downsideReturn: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "winProbability",
+        label: "Win p",
+        value: risk.winProbability,
+        percent: true,
+        onValue: (value) => updateDraft({ winProbability: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "upside",
+        label: "Upside",
+        value: risk.upsideReturn,
+        percent: true,
+        tone: "positive",
+        onValue: (value) => updateDraft({ upsideReturn: value } as Partial<KellySizerDraft>),
+      },
+    ];
+  }
+
+  if (mode === "prediction-market") {
+    const market = draft as KellySizerModeDrafts["prediction-market"];
+    return [
+      {
+        id: "side",
+        label: "Side",
+        valueText: market.side.toUpperCase(),
+        tone: "positive",
+        onPress: () => updateDraft({ side: market.side === "yes" ? "no" : "yes" } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "estimatedProbability",
+        label: "Est p",
+        value: market.estimatedProbability,
+        percent: true,
+        onValue: (value) => updateDraft({ estimatedProbability: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "marketPrice",
+        label: "Price",
+        value: market.marketPrice,
+        percent: true,
+        onValue: (value) => updateDraft({ marketPrice: value } as Partial<KellySizerDraft>),
+      },
+    ];
+  }
+
+  if (mode === "asymmetric") {
+    const asymmetric = draft as KellySizerModeDrafts["asymmetric"];
+    return [
+      {
+        id: "winProbability",
+        label: "Win p",
+        value: asymmetric.winProbability,
+        percent: true,
+        onValue: (value) => updateDraft({ winProbability: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "targetReturn",
+        label: "Target",
+        value: asymmetric.targetReturn,
+        percent: true,
+        tone: "positive",
+        onValue: (value) => updateDraft({ targetReturn: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "maxLossReturn",
+        label: "Max loss",
+        value: asymmetric.maxLossReturn,
+        percent: true,
+        allowNegative: true,
+        tone: "negative",
+        onValue: (value) => updateDraft({ maxLossReturn: value } as Partial<KellySizerDraft>),
+      },
+    ];
+  }
+
+  const binary = draft as KellySizerModeDrafts["binary"];
+  return [
+    {
+      id: "winProbability",
+      label: "Win p",
+      value: binary.winProbability,
+      percent: true,
+      onValue: (value) => updateDraft({ winProbability: value } as Partial<KellySizerDraft>),
+    },
+    {
+      id: "upside",
+      label: "Upside",
+      value: binary.upsideReturn,
+      percent: true,
+      tone: "positive",
+      onValue: (value) => updateDraft({ upsideReturn: value } as Partial<KellySizerDraft>),
+    },
+    {
+      id: "downside",
+      label: "Downside",
+      value: binary.downsideReturn,
+      percent: true,
+      allowNegative: true,
+      tone: "negative",
+      onValue: (value) => updateDraft({ downsideReturn: value } as Partial<KellySizerDraft>),
+    },
+  ];
+}
+
+export function buildCommonFields({
+  common,
+  updateCommon,
+}: {
+  common: KellyCommonAssumptions;
+  updateCommon: (patch: Partial<KellyCommonAssumptions>) => void;
+}): InlineField[] {
+  return [
+    {
+      id: "common:kellyFraction",
+      label: "Kelly",
+      value: common.kellyFraction,
+      percent: true,
+      onValue: (value) => updateCommon({ kellyFraction: value }),
+    },
+    {
+      id: "common:maxLoss",
+      label: "Loss cap",
+      value: common.maxLossFraction,
+      percent: true,
+      onValue: (value) => updateCommon({ maxLossFraction: value }),
+    },
+    {
+      id: "common:maxName",
+      label: "Name cap",
+      value: common.maxNameFraction,
+      percent: true,
+      onValue: (value) => updateCommon({ maxNameFraction: value }),
+    },
+  ];
+}