gloomberb 0.9.3 → 0.9.4

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

@@ -0,0 +1,197 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import { setSharedMarketDataCoordinator } from "../../../market-data/coordinator";
+import type { TickerRecord } from "../../../types/ticker";
+import { KellySizerHarness, createFinancials, createSizerConfig, createTicker } from "./test-support";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+async function renderPane(props?: Parameters<typeof KellySizerHarness>[0]) {
+  await act(async () => {
+    testSetup = await testRender(<KellySizerHarness {...props} />, { width: 100, height: 30 });
+    await Promise.resolve();
+    await testSetup.renderOnce();
+  });
+}
+
+async function flushFrame() {
+  await act(async () => {
+    await testSetup!.renderOnce();
+  });
+}
+
+beforeEach(() => {
+  setSharedMarketDataCoordinator(null);
+});
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => {
+      testSetup!.renderer.destroy();
+    });
+    testSetup = undefined;
+  }
+  setSharedMarketDataCoordinator(null);
+});
+
+describe("KellySizerPane", () => {
+  test("renders binary sizing context, result, and curve", async () => {
+    await renderPane();
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("AAPL · Main Portfolio");
+    expect(frame).toContain("Bankroll");
+    expect(frame).toContain("100000");
+    expect(frame).toContain("Win p");
+    expect(frame).toContain("Full Kelly");
+    expect(frame).toContain("Clipped");
+    expect(frame).toContain("Target val");
+    expect(frame).toContain("Current %");
+    expect(frame).toContain("Kelly Curve");
+    expect(frame).toContain("4.0% -> 8.0%");
+    expect(frame).toContain("growth");
+    expect(frame).toContain("loss cap");
+    expect(frame).toContain("cap max loss, max name");
+    expect(frame).toContain("full");
+    expect(frame).toContain("159%");
+    expect(frame).toContain("636%");
+    expect(frame).not.toContain("Mode");
+    expect(frame).not.toContain("Sensitivity");
+  });
+
+  test("prefills shared caps from plugin config", async () => {
+    const config = {
+      ...createSizerConfig(),
+      pluginConfig: {
+        "kelly-sizer": {
+          "commonAssumptions:v1": {
+            kellyFraction: 0.5,
+            maxLossFraction: 0.02,
+            maxNameFraction: 0.1,
+          },
+        },
+      },
+    };
+
+    await renderPane({ config, paneState: { mode: "scenario" } });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("Scenario");
+    expect(frame).toMatch(/Kelly\s+50\.0\s+%/);
+    expect(frame).toMatch(/Loss cap\s+2\.00\s+%/);
+    expect(frame).toMatch(/Name cap\s+10\.0\s+%/);
+  });
+
+  test("keeps shared caps scoped to pane state after seeding", async () => {
+    const config = {
+      ...createSizerConfig(),
+      pluginConfig: {
+        "kelly-sizer": {
+          "commonAssumptions:v1": {
+            kellyFraction: 0.5,
+            maxLossFraction: 0.02,
+            maxNameFraction: 0.1,
+          },
+        },
+      },
+    };
+
+    await renderPane({
+      config,
+      paneState: {
+        mode: "scenario",
+        "commonAssumptions:v1": {
+          kellyFraction: 0.3,
+          maxLossFraction: 0.015,
+          maxNameFraction: 0.07,
+        },
+      },
+    });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("Scenario");
+    expect(frame).toMatch(/Kelly\s+30\.0\s+%/);
+    expect(frame).toMatch(/Loss cap\s+1\.50\s+%/);
+    expect(frame).toMatch(/Name cap\s+7\.00\s+%/);
+    expect(frame).not.toMatch(/Kelly\s+50\.0\s+%/);
+  });
+
+  test("converts foreign quote current value to base currency", async () => {
+    const ticker = createTicker({
+      symbol: "SIVE",
+      currency: "SEK",
+      positions: [{
+        portfolio: "main",
+        shares: 100,
+        avgCost: 50,
+        currency: "SEK",
+        broker: "ibkr",
+        brokerInstanceId: "ibkr-flex",
+        brokerAccountId: "DU12345",
+        marketValue: 10_000,
+        unrealizedPnl: 5_000,
+      }],
+    });
+    const financials = createFinancials({ symbol: "SIVE", price: 100, currency: "SEK" });
+
+    await renderPane({
+      config: createSizerConfig("SIVE"),
+      ticker,
+      financials,
+      exchangeRates: new Map([["USD", 1], ["SEK", 0.1]]),
+    });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("SIVE · Main Portfolio");
+    expect(frame).toMatch(/Current\s+1000\s+USD/);
+    expect(frame).not.toMatch(/Current\s+10000\s+USD/);
+  });
+
+  test("toggles sensitivity with s", async () => {
+    await renderPane();
+    await flushFrame();
+
+    await act(async () => {
+      (testSetup!.renderer.keyInput as any).emit("keypress", {
+        name: "s",
+        sequence: "s",
+        ctrl: false,
+        meta: false,
+        shift: false,
+      });
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("Sensitivity");
+    expect(frame).toContain("Win p");
+    expect(frame).toContain("Upside");
+    expect(frame).not.toContain("Kelly Curve");
+  });
+
+  test("focuses ticker search with t", async () => {
+    await renderPane();
+    await flushFrame();
+
+    await act(async () => {
+      (testSetup!.renderer.keyInput as any).emit("keypress", {
+        name: "t",
+        sequence: "t",
+        ctrl: false,
+        meta: false,
+        shift: false,
+      });
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("/ AAPL");
+  });
+});

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

@@ -0,0 +1,47 @@
+import type { GloomPlugin, PaneTemplateContext, PaneTemplateCreateOptions } from "../../../types/plugin";
+import { DEFAULT_FLOATING_SIZE, KELLY_PANE_ID } from "./constants";
+import { KellySizerPane } from "./pane";
+
+function resolveTemplateSymbol(context: PaneTemplateContext, options?: PaneTemplateCreateOptions): string | null {
+  return options?.symbol
+    ?? options?.ticker?.metadata.ticker
+    ?? options?.arg?.trim().toUpperCase()
+    ?? context.activeTicker
+    ?? null;
+}
+
+export const kellySizerPlugin: GloomPlugin = {
+  id: KELLY_PANE_ID,
+  name: "Position Sizer",
+  version: "1.0.0",
+  description: "Size positions from Kelly, risk budget, and asymmetric payoff assumptions.",
+  toggleable: true,
+  panes: [
+    {
+      id: KELLY_PANE_ID,
+      name: "Position Sizer",
+      icon: "K",
+      component: KellySizerPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: DEFAULT_FLOATING_SIZE,
+    },
+  ],
+  paneTemplates: [
+    {
+      id: "kelly-sizer-pane",
+      paneId: KELLY_PANE_ID,
+      label: "Position Sizer",
+      description: "Open Kelly-based position sizing for a ticker.",
+      keywords: ["kelly", "position", "sizing", "risk", "bet", "portfolio"],
+      shortcut: { prefix: "KELLY", argPlaceholder: "ticker", argKind: "ticker", argOptional: true },
+      canCreate: (context, options) => !!resolveTemplateSymbol(context, options),
+      createInstance: (context, options) => {
+        const symbol = resolveTemplateSymbol(context, options);
+        return symbol ? { params: { symbol }, placement: "floating" } : null;
+      },
+    },
+  ],
+};
+
+export default kellySizerPlugin;

package/src/plugins/builtin/kelly-sizer/model.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildBinaryOutcomes,
+  buildKellyCurvePoints,
+  buildSensitivityGrid,
+  calculateKellySizing,
+  solveKellyFraction,
+  type BinaryKellyAssumptions,
+  type PredictionMarketKellyAssumptions,
+  type ScenarioKellyAssumptions,
+} from "./model";
+
+function expectClose(actual: number, expected: number, precision = 4) {
+  expect(actual).toBeGreaterThan(expected - precision);
+  expect(actual).toBeLessThan(expected + precision);
+}
+
+describe("kelly sizing model", () => {
+  test("solves classic even-money Kelly sizing", () => {
+    const result = solveKellyFraction(buildBinaryOutcomes(0.6, 1, -1));
+    expectClose(result.fraction, 0.2);
+    expectClose(result.expectedReturn, 0.2);
+  });
+
+  test("clips fractional binary Kelly by max name and max loss caps", () => {
+    const draft: BinaryKellyAssumptions = {
+      winProbability: 0.57,
+      upsideReturn: 0.24,
+      downsideReturn: -0.09,
+      kellyFraction: 0.25,
+      maxNameFraction: 0.08,
+      maxLossFraction: 0.01,
+    };
+
+    const result = calculateKellySizing({
+      mode: "binary",
+      draft,
+      bankroll: 100_000,
+      currentValue: 4_000,
+      price: 200,
+    });
+
+    expect(result.fullKellyFraction).toBeGreaterThan(4);
+    expectClose(result.clippedFraction, 0.08);
+    expect(result.clipReasons).toContain("max name");
+    expectClose(result.targetValue, 8_000, 0.01);
+    expectClose(result.addTrimValue, 4_000, 0.01);
+    expectClose(result.estimatedUnits ?? 0, 20, 0.01);
+    expectClose(result.riskFraction, 0.0072, 0.0001);
+  });
+
+  test("returns zero size when there is no positive edge", () => {
+    const draft: BinaryKellyAssumptions = {
+      winProbability: 0.45,
+      upsideReturn: 0.1,
+      downsideReturn: -0.1,
+      kellyFraction: 0.25,
+      maxNameFraction: 0.2,
+      maxLossFraction: 0.05,
+    };
+
+    const result = calculateKellySizing({
+      mode: "binary",
+      draft,
+      bankroll: 10_000,
+    });
+
+    expect(result.clippedFraction).toBe(0);
+    expect(result.warnings).toContain("No positive Kelly edge.");
+  });
+
+  test("solves scenario trees numerically", () => {
+    const draft: ScenarioKellyAssumptions = {
+      outcomes: [
+        { id: "loss", label: "Loss", probability: 0.4, returnPct: -1 },
+        { id: "win", label: "Win", probability: 0.6, returnPct: 1 },
+      ],
+      kellyFraction: 1,
+      maxNameFraction: 1,
+      maxLossFraction: 1,
+    };
+
+    const result = calculateKellySizing({
+      mode: "scenario",
+      draft,
+      bankroll: 1_000,
+    });
+
+    expectClose(result.fullKellyFraction, 0.2);
+    expectClose(result.clippedFraction, 0.2);
+  });
+
+  test("uses risk budget size before Kelly when in risk budget mode", () => {
+    const result = calculateKellySizing({
+      mode: "risk-budget",
+      draft: {
+        riskBudgetFraction: 0.01,
+        downsideReturn: -0.1,
+        winProbability: 0.6,
+        upsideReturn: 0.2,
+        kellyFraction: 0.25,
+        maxNameFraction: 1,
+        maxLossFraction: 1,
+      },
+      bankroll: 50_000,
+    });
+
+    expectClose(result.unclippedFraction, 0.1);
+    expectClose(result.clippedFraction, 0.1);
+    expectClose(result.riskValue, 500);
+  });
+
+  test("sizes prediction market yes contracts from probability and price", () => {
+    const draft: PredictionMarketKellyAssumptions = {
+      estimatedProbability: 0.57,
+      marketPrice: 0.48,
+      side: "yes",
+      kellyFraction: 1,
+      maxNameFraction: 1,
+      maxLossFraction: 1,
+    };
+
+    const result = calculateKellySizing({
+      mode: "prediction-market",
+      draft,
+      bankroll: 1_000,
+    });
+
+    expectClose(result.fullKellyFraction, 0.173076, 0.0001);
+    expectClose(result.clippedFraction, 0.173076, 0.0001);
+  });
+
+  test("builds sensitivity grid and Kelly curve data", () => {
+    const draft: BinaryKellyAssumptions = {
+      winProbability: 0.57,
+      upsideReturn: 0.24,
+      downsideReturn: -0.09,
+      kellyFraction: 0.25,
+      maxNameFraction: 0.08,
+      maxLossFraction: 0.01,
+    };
+
+    const grid = buildSensitivityGrid("binary", draft);
+    expect(grid.rows).toHaveLength(3);
+    expect(grid.columns).toHaveLength(3);
+    expect(grid.cells[1]?.[1]?.text).toBe("8.00%");
+
+    const points = buildKellyCurvePoints("binary", draft);
+    expect(points.length).toBeGreaterThan(10);
+    expect(points[0]?.close).toBe(0);
+  });
+});