gloomberb 0.9.3 → 0.9.5

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);
+  });
+});