gloomberb 0.9.3 → 0.9.4

package/src/plugins/builtin/kelly-sizer/sections.tsx

@@ -0,0 +1,142 @@
+import { Box, Text, TextAttributes } from "../../../ui";
+import { StaticChartSurface } from "../../../components";
+import { resolveChartPalette } from "../../../components/chart/core/renderer";
+import type { StaticChartXMarker } from "../../../components/chart/static/chart/surface";
+import { colors, priceColor } from "../../../theme/colors";
+import { formatCompact, formatCurrency, formatNumber } from "../../../utils/format";
+import type { ProjectedChartPoint } from "../../../components/chart/core/data";
+import type { KellySizerDraft, KellySizingResult, SensitivityGrid } from "./model";
+import {
+  KellyCurveDecisionView,
+  MetricLine,
+  SensitivityGridView,
+  formatPct,
+  formatSignedPct,
+} from "./view";
+
+export function KellyResultMetrics({
+  result,
+  activeDraft,
+  baseCurrency,
+  leftWidth,
+  rightWidth,
+}: {
+  result: KellySizingResult;
+  activeDraft: KellySizerDraft;
+  baseCurrency: string;
+  leftWidth: number;
+  rightWidth: number;
+}) {
+  return (
+    <Box flexDirection="row" paddingX={1}>
+      <Box flexDirection="column" width={leftWidth}>
+        <MetricLine width={leftWidth} label="Full Kelly" value={formatPct(result.fullKellyFraction, 1)} />
+        <MetricLine width={leftWidth} label="Fractional" value={formatPct(result.fractionalKellyFraction, 1)} detail={formatPct(activeDraft.kellyFraction, 0)} />
+        <MetricLine
+          width={leftWidth}
+          label="Clipped"
+          value={formatPct(result.clippedFraction, 2)}
+          detail={result.clipReasons.length > 0 ? result.clipReasons.join(", ") : undefined}
+          color={result.clipReasons.length > 0 ? colors.positive : colors.text}
+        />
+        <MetricLine width={leftWidth} label="Target val" value={formatCurrency(result.targetValue, baseCurrency)} />
+        <MetricLine
+          width={leftWidth}
+          label="Add / trim"
+          value={formatCurrency(result.addTrimValue, baseCurrency)}
+          color={priceColor(result.addTrimValue)}
+        />
+        <MetricLine
+          width={leftWidth}
+          label="Units"
+          value={result.estimatedUnits == null ? "—" : formatNumber(result.estimatedUnits, 1)}
+        />
+      </Box>
+      <Box flexDirection="column" width={rightWidth}>
+        <MetricLine width={rightWidth} label="Risk" value={formatCurrency(result.riskValue, baseCurrency)} detail={formatPct(result.riskFraction, 2)} color={colors.negative} />
+        <MetricLine width={rightWidth} label="Worst loss" value={formatPct(result.downsideLossFraction, 1)} />
+        <MetricLine width={rightWidth} label="Current %" value={formatPct(result.currentFraction, 1)} />
+        <MetricLine width={rightWidth} label="Exp return" value={formatSignedPct(result.expectedReturn)} color={priceColor(result.expectedReturn)} />
+        <MetricLine width={rightWidth} label="Log growth" value={formatCompact(result.expectedLogGrowth)} />
+      </Box>
+    </Box>
+  );
+}
+
+export function KellyCurveSection({
+  width,
+  height,
+  points,
+  xAxisLabels,
+  curveMaxFraction,
+  markers,
+  result,
+  currentGrowth,
+  targetGrowth,
+  baseCurrency,
+}: {
+  width: number;
+  height: number;
+  points: ProjectedChartPoint[];
+  xAxisLabels: string[];
+  curveMaxFraction: number;
+  markers: StaticChartXMarker[];
+  result: KellySizingResult;
+  currentGrowth: number;
+  targetGrowth: number;
+  baseCurrency: string;
+}) {
+  return (
+    <>
+      <Box height={1} paddingX={1}>
+        <Text fg={colors.textDim} attributes={TextAttributes.BOLD}>Kelly Curve</Text>
+      </Box>
+      <Box paddingX={1} height={height}>
+        <StaticChartSurface
+          points={points}
+          width={Math.max(10, width - 2)}
+          height={height}
+          mode="line"
+          axisMode="percent"
+          colors={resolveChartPalette(colors, "positive")}
+          yAxisLabel="Expected log growth"
+          yAxisColor={colors.textDim}
+          formatYAxisValue={(value) => formatSignedPct(value)}
+          xAxisLabels={xAxisLabels}
+          xAxisColor={colors.textDim}
+          formatXAxisCursorValue={(ratio) => formatPct(curveMaxFraction * ratio, 1)}
+          xMarkers={markers}
+        />
+      </Box>
+      <KellyCurveDecisionView
+        width={Math.max(10, width - 2)}
+        currentFraction={result.currentFraction}
+        targetFraction={result.clippedFraction}
+        fullKellyFraction={result.fullKellyFraction}
+        currentGrowth={currentGrowth}
+        targetGrowth={targetGrowth}
+        addTrimValue={result.addTrimValue}
+        currency={baseCurrency}
+        clipReasons={result.clipReasons}
+      />
+    </>
+  );
+}
+
+export function KellySensitivitySection({
+  width,
+  sensitivity,
+}: {
+  width: number;
+  sensitivity: SensitivityGrid;
+}) {
+  return (
+    <>
+      <Box height={1} paddingX={1} flexDirection="row">
+        <Text fg={colors.textDim} attributes={TextAttributes.BOLD}>Sensitivity</Text>
+        <Text fg={colors.textDim}>{`  ${sensitivity.columnLabel}`}</Text>
+      </Box>
+      <SensitivityGridView width={Math.max(10, width - 2)} grid={sensitivity} />
+    </>
+  );
+}

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

@@ -0,0 +1,67 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { usePaneStateValue } from "../../../state/app/context";
+import { usePluginConfigState } from "../../runtime";
+import { COMMON_ASSUMPTIONS_STATE_KEY } from "./constants";
+import {
+  DEFAULT_KELLY_COMMON_ASSUMPTIONS,
+  normalizeKellyCommonAssumptions,
+  type KellyCommonAssumptions,
+  type KellySizerDraft,
+} from "./model";
+
+export function useKellyCommonAssumptions(rawActiveDraft: KellySizerDraft): {
+  commonAssumptions: KellyCommonAssumptions;
+  updateCommon: (patch: Partial<KellyCommonAssumptions>) => void;
+} {
+  const commonFallback = useMemo(
+    () => normalizeKellyCommonAssumptions(rawActiveDraft, DEFAULT_KELLY_COMMON_ASSUMPTIONS),
+    [rawActiveDraft],
+  );
+  const [storedCommonAssumptions, setStoredCommonAssumptions] = usePluginConfigState<KellyCommonAssumptions>(
+    COMMON_ASSUMPTIONS_STATE_KEY,
+    commonFallback,
+  );
+  const [paneCommonAssumptions, setPaneCommonAssumptions] = usePaneStateValue<KellyCommonAssumptions | null>(
+    COMMON_ASSUMPTIONS_STATE_KEY,
+    null,
+  );
+  const seededCommonAssumptions = useMemo(
+    () => normalizeKellyCommonAssumptions(storedCommonAssumptions, commonFallback),
+    [commonFallback, storedCommonAssumptions],
+  );
+  const [localCommonAssumptions, setLocalCommonAssumptions] = useState<KellyCommonAssumptions | null>(null);
+
+  useEffect(() => {
+    if (paneCommonAssumptions === null) {
+      setPaneCommonAssumptions(seededCommonAssumptions);
+    }
+  }, [paneCommonAssumptions, seededCommonAssumptions, setPaneCommonAssumptions]);
+
+  useEffect(() => {
+    if (localCommonAssumptions !== null) return;
+    setLocalCommonAssumptions(normalizeKellyCommonAssumptions(
+      paneCommonAssumptions ?? seededCommonAssumptions,
+      seededCommonAssumptions,
+    ));
+  }, [localCommonAssumptions, paneCommonAssumptions, seededCommonAssumptions]);
+
+  const commonAssumptions = useMemo(
+    () => normalizeKellyCommonAssumptions(
+      localCommonAssumptions ?? paneCommonAssumptions ?? seededCommonAssumptions,
+      seededCommonAssumptions,
+    ),
+    [localCommonAssumptions, paneCommonAssumptions, seededCommonAssumptions],
+  );
+
+  const updateCommon = useCallback((patch: Partial<KellyCommonAssumptions>) => {
+    const next = normalizeKellyCommonAssumptions({
+      ...commonAssumptions,
+      ...patch,
+    }, commonAssumptions);
+    setLocalCommonAssumptions(next);
+    setPaneCommonAssumptions(next);
+    setStoredCommonAssumptions(next);
+  }, [commonAssumptions, setPaneCommonAssumptions, setStoredCommonAssumptions]);
+
+  return { commonAssumptions, updateCommon };
+}

package/src/plugins/builtin/kelly-sizer/test-support.tsx

@@ -0,0 +1,174 @@
+import { useReducer, type ReactElement } from "react";
+import {
+  AppContext,
+  appReducer,
+  createInitialState,
+  PaneInstanceProvider,
+} from "../../../state/app/context";
+import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
+import { cloneLayout, createDefaultConfig, type AppConfig } from "../../../types/config";
+import type { TickerFinancials } from "../../../types/financials";
+import type { TickerRecord } from "../../../types/ticker";
+import type { BrokerAccount } from "../../../types/trading";
+import { PluginRenderProvider } from "../../runtime";
+import { kellySizerPlugin } from "./index";
+
+export const TEST_PANE_ID = "kelly-sizer:test";
+
+const KellySizerPane = kellySizerPlugin.panes![0]!.component as (props: {
+  paneId: string;
+  paneType: string;
+  focused: boolean;
+  width: number;
+  height: number;
+}) => ReactElement;
+
+export function createSizerConfig(symbol = "AAPL"): AppConfig {
+  const baseConfig = createDefaultConfig("/tmp/gloomberb-kelly-sizer");
+  const layout: AppConfig["layout"] = {
+    dockRoot: { kind: "pane", instanceId: TEST_PANE_ID },
+    instances: [{
+      instanceId: TEST_PANE_ID,
+      paneId: "kelly-sizer",
+      binding: { kind: "none" },
+      params: { symbol },
+    }],
+    floating: [],
+    detached: [],
+  };
+
+  return {
+    ...baseConfig,
+    brokerInstances: [{
+      id: "ibkr-flex",
+      brokerType: "ibkr",
+      label: "IBKR Flex",
+      config: {},
+    }],
+    portfolios: [{
+      id: "main",
+      name: "Main Portfolio",
+      currency: "USD",
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-flex",
+      brokerAccountId: "DU12345",
+    }],
+    layout,
+    layouts: [{ name: "Default", layout: cloneLayout(layout) }],
+  };
+}
+
+export function createTicker({
+  symbol = "AAPL",
+  currency = "USD",
+  positions,
+}: {
+  symbol?: string;
+  currency?: string;
+  positions?: TickerRecord["metadata"]["positions"];
+} = {}): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange: "NASDAQ",
+      currency,
+      name: symbol === "AAPL" ? "Apple" : symbol,
+      sector: "Technology",
+      portfolios: ["main"],
+      watchlists: [],
+      positions: positions ?? [{
+        portfolio: "main",
+        shares: 20,
+        avgCost: 180,
+        currency,
+        broker: "ibkr",
+        brokerInstanceId: "ibkr-flex",
+        brokerAccountId: "DU12345",
+        marketValue: 4_000,
+        unrealizedPnl: 400,
+      }],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+export function createFinancials({
+  symbol = "AAPL",
+  price = 200,
+  currency = "USD",
+}: {
+  symbol?: string;
+  price?: number;
+  currency?: string;
+} = {}): TickerFinancials {
+  return {
+    annualStatements: [],
+    quarterlyStatements: [],
+    priceHistory: [],
+    quote: {
+      symbol,
+      price,
+      currency,
+      change: price * 0.01,
+      changePercent: 1,
+      previousClose: price * 0.99,
+      lastUpdated: Date.now(),
+    },
+  };
+}
+
+function createBrokerAccount(): BrokerAccount {
+  return {
+    accountId: "DU12345",
+    name: "DU12345",
+    currency: "USD",
+    source: "flex",
+    updatedAt: Date.now(),
+    totalCashValue: 20_000,
+    netLiquidation: 100_000,
+    dailyPnl: 0,
+    unrealizedPnl: 400,
+    cashBalances: [],
+  };
+}
+
+export function KellySizerHarness({
+  config = createSizerConfig(),
+  ticker = createTicker(),
+  financials = createFinancials({ symbol: ticker.metadata.ticker, currency: ticker.metadata.currency }),
+  exchangeRates,
+  paneState,
+}: {
+  config?: AppConfig;
+  ticker?: TickerRecord;
+  financials?: TickerFinancials;
+  exchangeRates?: Map<string, number>;
+  paneState?: Record<string, unknown>;
+}) {
+  const initialState = createInitialState(config);
+  initialState.focusedPaneId = TEST_PANE_ID;
+  if (paneState) initialState.paneState[TEST_PANE_ID] = paneState;
+  initialState.tickers = new Map([[ticker.metadata.ticker, ticker]]);
+  initialState.financials = new Map([[ticker.metadata.ticker, financials]]);
+  if (exchangeRates) initialState.exchangeRates = exchangeRates;
+  initialState.brokerAccounts = { "ibkr-flex": [createBrokerAccount()] };
+
+  const [state, dispatch] = useReducer(appReducer, initialState);
+
+  return (
+    <AppContext value={{ state, dispatch }}>
+      <PaneInstanceProvider paneId={TEST_PANE_ID}>
+        <PluginRenderProvider pluginId={kellySizerPlugin.id} runtime={createTestPluginRuntime()}>
+          <KellySizerPane
+            paneId={TEST_PANE_ID}
+            paneType="kelly-sizer"
+            focused
+            width={100}
+            height={30}
+          />
+        </PluginRenderProvider>
+      </PaneInstanceProvider>
+    </AppContext>
+  );
+}

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

@@ -0,0 +1,156 @@
+export type KellySizingMode =
+  | "binary"
+  | "scenario"
+  | "risk-budget"
+  | "prediction-market"
+  | "asymmetric";
+
+export interface KellyCommonAssumptions {
+  kellyFraction: number;
+  maxNameFraction: number;
+  maxLossFraction: number;
+}
+
+export interface BinaryKellyAssumptions extends KellyCommonAssumptions {
+  winProbability: number;
+  upsideReturn: number;
+  downsideReturn: number;
+}
+
+export interface ScenarioKellyOutcome {
+  id: string;
+  label: string;
+  probability: number;
+  returnPct: number;
+}
+
+export interface ScenarioKellyAssumptions extends KellyCommonAssumptions {
+  outcomes: ScenarioKellyOutcome[];
+}
+
+export interface RiskBudgetKellyAssumptions extends KellyCommonAssumptions {
+  riskBudgetFraction: number;
+  downsideReturn: number;
+  winProbability: number;
+  upsideReturn: number;
+}
+
+export interface PredictionMarketKellyAssumptions extends KellyCommonAssumptions {
+  estimatedProbability: number;
+  marketPrice: number;
+  side: "yes" | "no";
+}
+
+export interface AsymmetricKellyAssumptions extends KellyCommonAssumptions {
+  winProbability: number;
+  targetReturn: number;
+  maxLossReturn: number;
+}
+
+export interface KellySizerModeDrafts {
+  binary: BinaryKellyAssumptions;
+  scenario: ScenarioKellyAssumptions;
+  "risk-budget": RiskBudgetKellyAssumptions;
+  "prediction-market": PredictionMarketKellyAssumptions;
+  asymmetric: AsymmetricKellyAssumptions;
+}
+
+export type KellySizerDraft = KellySizerModeDrafts[KellySizingMode];
+
+export interface KellyOutcome {
+  probability: number;
+  returnPct: number;
+}
+
+export interface KellySolveResult {
+  fraction: number;
+  expectedReturn: number;
+  expectedLogGrowth: number;
+  warning?: string;
+}
+
+export interface KellySizingResult {
+  mode: KellySizingMode;
+  bankroll: number;
+  currentValue: number;
+  currentFraction: number;
+  price: number | null;
+  fullKellyFraction: number;
+  fractionalKellyFraction: number;
+  unclippedFraction: number;
+  clippedFraction: number;
+  targetValue: number;
+  addTrimValue: number;
+  estimatedUnits: number | null;
+  downsideLossFraction: number;
+  riskValue: number;
+  riskFraction: number;
+  expectedReturn: number;
+  expectedLogGrowth: number;
+  warnings: string[];
+  clipReasons: string[];
+  recommendationLabel: string;
+}
+
+export interface SensitivityGridCell {
+  fraction: number | null;
+  text: string;
+}
+
+export interface SensitivityGrid {
+  rowLabel: string;
+  columnLabel: string;
+  rows: string[];
+  columns: string[];
+  cells: SensitivityGridCell[][];
+}
+
+export const KELLY_MODES: Array<{ id: KellySizingMode; label: string }> = [
+  { id: "binary", label: "Binary" },
+  { id: "scenario", label: "Scenario" },
+  { id: "risk-budget", label: "Risk" },
+  { id: "prediction-market", label: "Market" },
+  { id: "asymmetric", label: "Asym" },
+];
+
+export const DEFAULT_KELLY_COMMON_ASSUMPTIONS: KellyCommonAssumptions = {
+  kellyFraction: 0.25,
+  maxNameFraction: 0.08,
+  maxLossFraction: 0.01,
+};
+
+export const DEFAULT_KELLY_DRAFTS: KellySizerModeDrafts = {
+  binary: {
+    winProbability: 0.57,
+    upsideReturn: 0.24,
+    downsideReturn: -0.09,
+    ...DEFAULT_KELLY_COMMON_ASSUMPTIONS,
+  },
+  scenario: {
+    outcomes: [
+      { id: "bear", label: "Bear", probability: 0.25, returnPct: -0.12 },
+      { id: "base", label: "Base", probability: 0.45, returnPct: 0.08 },
+      { id: "bull", label: "Bull", probability: 0.30, returnPct: 0.28 },
+    ],
+    ...DEFAULT_KELLY_COMMON_ASSUMPTIONS,
+  },
+  "risk-budget": {
+    riskBudgetFraction: 0.01,
+    downsideReturn: -0.09,
+    winProbability: 0.57,
+    upsideReturn: 0.24,
+    ...DEFAULT_KELLY_COMMON_ASSUMPTIONS,
+  },
+  "prediction-market": {
+    estimatedProbability: 0.57,
+    marketPrice: 0.48,
+    side: "yes",
+    ...DEFAULT_KELLY_COMMON_ASSUMPTIONS,
+  },
+  asymmetric: {
+    winProbability: 0.42,
+    targetReturn: 1.5,
+    maxLossReturn: -1,
+    ...DEFAULT_KELLY_COMMON_ASSUMPTIONS,
+  },
+};

package/src/plugins/builtin/kelly-sizer/view.test.tsx

@@ -0,0 +1,77 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act, useState, type Dispatch, type SetStateAction } from "react";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import { InlineFieldView } from "./view";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let setFieldActive: Dispatch<SetStateAction<boolean>> | null = null;
+
+afterEach(async () => {
+  setFieldActive = null;
+  if (!testSetup) return;
+  await act(async () => {
+    testSetup!.renderer.destroy();
+  });
+  testSetup = undefined;
+});
+
+function InlineFieldHarness({ commits }: { commits: number[] }) {
+  const [active, setActive] = useState(false);
+  const [value, setValue] = useState(0.01);
+  setFieldActive = setActive;
+
+  return (
+    <InlineFieldView
+      field={{
+        id: "loss-cap",
+        label: "Loss cap",
+        value,
+        percent: true,
+        onValue: (nextValue) => {
+          commits.push(nextValue);
+          setValue(nextValue);
+        },
+      }}
+      active={active}
+      focused
+      width={30}
+      onFocus={() => setActive(true)}
+    />
+  );
+}
+
+describe("InlineFieldView", () => {
+  test("replaces the formatted value and commits when focus leaves the active field", async () => {
+    const commits: number[] = [];
+    testSetup = await testRender(<InlineFieldHarness commits={commits} />, { width: 36, height: 4 });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      setFieldActive?.(true);
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      await testSetup!.mockInput.typeText("2");
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      setFieldActive?.(false);
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(commits.at(-1)).toBeCloseTo(0.02);
+    expect(testSetup.captureCharFrame()).toContain("2.00");
+  });
+});