gloomberb 0.2.0 → 0.3.2

package/src/plugins/prediction-markets/detail.test.tsx

@@ -0,0 +1,47 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import {
+  ChartHarness,
+  GroupedDetailHarness,
+  cleanupPredictionTest,
+  flushFrames,
+} from "./test-helpers";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+afterEach(async () => {
+  await cleanupPredictionTest(testSetup);
+  testSetup = undefined;
+});
+
+describe("prediction markets detail views", () => {
+  test("renders chart history even when cached dates are plain strings", async () => {
+    testSetup = await testRender(
+      <ChartHarness
+        history={[
+          { date: "2026-04-01T00:00:00Z", close: 0.45 },
+          { date: "2026-04-02T00:00:00Z", close: 0.48 },
+        ]}
+      />,
+      { width: 80, height: 12 },
+    );
+    await flushFrames(testSetup);
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("1M");
+    expect(frame).not.toContain("TypeError");
+  });
+
+  test("renders grouped selections as ranked outcomes in the detail overview", async () => {
+    testSetup = await testRender(<GroupedDetailHarness />, {
+      width: 64,
+      height: 24,
+    });
+    await flushFrames(testSetup);
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Outcomes");
+    expect(frame).toContain("Above 4.25%");
+    expect(frame).toContain("Above 4.50%");
+  });
+});

package/src/plugins/prediction-markets/index.tsx

@@ -0,0 +1,102 @@
+import type { GloomPlugin, GloomPluginContext } from "../../types/plugin";
+import { parsePredictionSearchShortcut } from "./navigation";
+import { PredictionMarketsPane } from "./pane";
+import { attachPredictionMarketsPersistence } from "./services/fetch";
+import {
+  buildPredictionMarketsPaneSettingsDef,
+  createPredictionMarketsPaneSettings,
+  getPredictionMarketsPaneSettings,
+} from "./settings";
+
+const PANE_ID = "prediction-markets";
+const MAIN_INSTANCE_ID = `${PANE_ID}:main`;
+
+function openPredictionMarkets(ctx: GloomPluginContext, query = ""): void {
+  const parsed = parsePredictionSearchShortcut(query);
+  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "venueScope", parsed.venueScope);
+  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "searchQuery", parsed.searchQuery);
+  ctx.resume.setPaneState(MAIN_INSTANCE_ID, "selectedMarketKey", null);
+  ctx.focusPane(PANE_ID);
+}
+
+export const predictionMarketsPlugin: GloomPlugin = {
+  id: PANE_ID,
+  name: "Prediction Markets",
+  version: "1.0.0",
+  description:
+    "Browse prediction markets (Polymarket and Kalshi).",
+  toggleable: true,
+  panes: [
+    {
+      id: PANE_ID,
+      name: "Prediction Markets",
+      icon: "M",
+      component: PredictionMarketsPane,
+      defaultPosition: "left",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 132, height: 36 },
+      settings: (context) =>
+        buildPredictionMarketsPaneSettingsDef(
+          context.config,
+          getPredictionMarketsPaneSettings(context.settings),
+        ),
+    },
+  ],
+  paneTemplates: [
+    {
+      id: "new-prediction-markets-pane",
+      paneId: PANE_ID,
+      label: "Prediction Markets",
+      description: "Open a new prediction markets browser pane",
+      keywords: ["prediction", "markets", "polymarket", "kalshi", "events"],
+      shortcut: { prefix: "PM", argPlaceholder: "query", argKind: "text" },
+      createInstance: (_context, options) => {
+        const parsed = parsePredictionSearchShortcut(options?.arg ?? "");
+        return {
+          placement: "floating",
+          params: {
+            query: parsed.searchQuery,
+            scope: parsed.venueScope,
+          },
+          settings: createPredictionMarketsPaneSettings() as unknown as Record<
+            string,
+            unknown
+          >,
+        };
+      },
+    },
+  ],
+  setup(ctx) {
+    attachPredictionMarketsPersistence(ctx.persistence);
+
+    ctx.registerCommand({
+      id: "prediction-markets-open",
+      label: "Open Prediction Markets",
+      description: "Focus the prediction markets browser pane.",
+      keywords: ["prediction", "markets", "polymarket", "kalshi", "open"],
+      category: "navigation",
+      execute: async () => {
+        ctx.focusPane(PANE_ID);
+      },
+    });
+
+    ctx.registerCommand({
+      id: "prediction-markets-search",
+      label: "Search Prediction Markets",
+      description: "Open the prediction markets pane and seed a search query.",
+      keywords: ["prediction", "markets", "search", "polymarket", "kalshi"],
+      category: "navigation",
+      wizard: [
+        {
+          key: "query",
+          label: "Prediction market query",
+          placeholder: "fed or polymarket:fed",
+          type: "text",
+        },
+      ],
+      execute: async (values) => {
+        openPredictionMarkets(ctx, values?.query ?? "");
+      },
+    });
+  },
+};

package/src/plugins/prediction-markets/keyboard.ts

@@ -0,0 +1,64 @@
+export type PredictionKeyboardCommand =
+  | "escape"
+  | "search"
+  | "move-down"
+  | "move-up"
+  | "previous-category"
+  | "next-category"
+  | "previous-venue-tab"
+  | "next-venue-tab"
+  | "toggle-watchlist"
+  | "browse-top"
+  | "browse-ending"
+  | "browse-new"
+  | "browse-watchlist";
+
+export interface PredictionKeyboardEventLike {
+  name?: string;
+  sequence?: string;
+  shift?: boolean;
+}
+
+function matchesPredictionKey(
+  event: PredictionKeyboardEventLike,
+  names: string[],
+  sequences: string[] = [],
+): boolean {
+  const normalizedName = event.name?.toLowerCase();
+  if (normalizedName && names.includes(normalizedName)) return true;
+  return sequences.includes(event.sequence ?? "");
+}
+
+export function resolvePredictionKeyboardCommand(
+  event: PredictionKeyboardEventLike,
+): PredictionKeyboardCommand | null {
+  if (matchesPredictionKey(event, ["escape", "esc"], ["\u001b"]))
+    return "escape";
+  if (matchesPredictionKey(event, ["/"], ["/"])) return "search";
+  if (matchesPredictionKey(event, ["down", "j"], ["j", "\u001b[B", "\u001bOB"]))
+    return "move-down";
+  if (matchesPredictionKey(event, ["up", "k"], ["k", "\u001b[A", "\u001bOA"]))
+    return "move-up";
+  if (
+    event.shift &&
+    matchesPredictionKey(event, ["left", "h"], ["H", "\u001b[1;2D"])
+  )
+    return "previous-venue-tab";
+  if (
+    event.shift &&
+    matchesPredictionKey(event, ["right", "l"], ["L", "\u001b[1;2C"])
+  )
+    return "next-venue-tab";
+  if (matchesPredictionKey(event, ["left", "h"], ["h", "\u001b[D", "\u001bOD"]))
+    return "previous-category";
+  if (
+    matchesPredictionKey(event, ["right", "l"], ["l", "\u001b[C", "\u001bOC"])
+  )
+    return "next-category";
+  if (matchesPredictionKey(event, ["w"], ["w"])) return "toggle-watchlist";
+  if (matchesPredictionKey(event, ["1"], ["1"])) return "browse-top";
+  if (matchesPredictionKey(event, ["2"], ["2"])) return "browse-ending";
+  if (matchesPredictionKey(event, ["3"], ["3"])) return "browse-new";
+  if (matchesPredictionKey(event, ["4"], ["4"])) return "browse-watchlist";
+  return null;
+}

package/src/plugins/prediction-markets/launch.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "bun:test";
+import { createDefaultConfig } from "../../types/config";
+import type { AppSessionSnapshot } from "../../state/session-persistence";
+import {
+  applyPredictionLaunchIntentToConfig,
+  applyPredictionLaunchIntentToSessionSnapshot,
+  parsePredictionLaunchArgs,
+} from "./launch";
+
+describe("prediction markets launch", () => {
+  test("parses prediction launch args", () => {
+    expect(parsePredictionLaunchArgs(["predictions"])).toEqual({
+      venueScope: "all",
+      categoryId: "all",
+      browseTab: "top",
+      searchQuery: "",
+    });
+    expect(parsePredictionLaunchArgs(["predictions", "world"])).toEqual({
+      venueScope: "all",
+      categoryId: "world",
+      browseTab: "top",
+      searchQuery: "",
+    });
+    expect(
+      parsePredictionLaunchArgs([
+        "predictions",
+        "polymarket",
+        "world",
+        "ending",
+        "iran",
+      ]),
+    ).toEqual({
+      venueScope: "polymarket",
+      categoryId: "world",
+      browseTab: "ending",
+      searchQuery: "iran",
+    });
+    expect(parsePredictionLaunchArgs(["ticker", "AAPL"])).toBeNull();
+  });
+
+  test("injects a prediction pane into the active layout when missing", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-launch-test");
+
+    const result = applyPredictionLaunchIntentToConfig(
+      config,
+      {
+        venueScope: "all",
+        categoryId: "world",
+        browseTab: "top",
+        searchQuery: "iran",
+      },
+      { width: 140, height: 42 },
+    );
+
+    expect(
+      result.config.layout.instances.some(
+        (instance) =>
+          instance.paneId === "prediction-markets" &&
+          instance.instanceId === result.paneInstanceId,
+      ),
+    ).toBe(true);
+    expect(
+      result.config.layout.floating.some(
+        (entry) => entry.instanceId === result.paneInstanceId,
+      ),
+    ).toBe(true);
+    expect(
+      result.config.layouts[result.config.activeLayoutIndex]?.layout.instances.some(
+        (instance) => instance.instanceId === result.paneInstanceId,
+      ),
+    ).toBe(true);
+  });
+
+  test("seeds pane state and focus for prediction launch", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-launch-session-test");
+    const launch = applyPredictionLaunchIntentToConfig(
+      config,
+      {
+        venueScope: "polymarket",
+        categoryId: "world",
+        browseTab: "top",
+        searchQuery: "iran",
+      },
+      { width: 140, height: 42 },
+    );
+    const snapshot: AppSessionSnapshot = {
+      paneState: {},
+      focusedPaneId: "portfolio-list:main",
+      activePanel: "left",
+      statusBarVisible: true,
+      openPaneIds: ["portfolio-list:main"],
+      hydrationTargets: [],
+      exchangeCurrencies: [],
+      savedAt: 1,
+    };
+
+    const seeded = applyPredictionLaunchIntentToSessionSnapshot(
+      launch.config,
+      snapshot,
+      launch.paneInstanceId,
+      {
+        venueScope: "polymarket",
+        categoryId: "world",
+        browseTab: "top",
+        searchQuery: "iran",
+      },
+    );
+
+    expect(seeded.focusedPaneId).toBe(launch.paneInstanceId);
+    expect(seeded.openPaneIds).toContain(launch.paneInstanceId);
+    const pluginState = seeded.paneState[launch.paneInstanceId]?.pluginState as
+      | Record<string, Record<string, unknown>>
+      | undefined;
+
+    expect(
+      pluginState?.["prediction-markets"],
+    ).toMatchObject({
+      venueScope: "polymarket",
+      categoryId: "world",
+      browseTab: "top",
+      searchQuery: "iran",
+      selectedRowKey: null,
+      selectedDetailMarketKey: null,
+    });
+  });
+});

package/src/plugins/prediction-markets/launch.ts

@@ -0,0 +1,240 @@
+import type { ReactNode } from "react";
+import { getDockedPaneIds, addPaneFloating, bringToFront, isPaneInLayout } from "../pane-manager";
+import {
+  cloneLayout,
+  createPaneInstance,
+  findPaneInstance,
+  type AppConfig,
+  type SavedLayout,
+} from "../../types/config";
+import type { PaneDef } from "../../types/plugin";
+import type { AppSessionSnapshot } from "../../state/session-persistence";
+import { PREDICTION_CATEGORY_OPTIONS, type PredictionCategoryId } from "./categories";
+import { BROWSE_TABS } from "./navigation";
+import type { PredictionBrowseTab, PredictionVenueScope } from "./types";
+
+const PREDICTION_PANE_ID = "prediction-markets";
+const PREDICTION_MAIN_INSTANCE_ID = `${PREDICTION_PANE_ID}:main`;
+
+const VENUE_SCOPE_SET = new Set<PredictionVenueScope>([
+  "all",
+  "polymarket",
+  "kalshi",
+]);
+const CATEGORY_ID_SET = new Set<PredictionCategoryId>(
+  PREDICTION_CATEGORY_OPTIONS.map((option) => option.id),
+);
+const BROWSE_TAB_SET = new Set<PredictionBrowseTab>(
+  BROWSE_TABS.map((tab) => tab.value),
+);
+
+const PREDICTION_FLOATING_PANE_DEF: PaneDef = {
+  id: PREDICTION_PANE_ID,
+  name: "Prediction Markets",
+  component: () => null as ReactNode,
+  defaultPosition: "left",
+  defaultMode: "floating",
+  defaultFloatingSize: { width: 132, height: 36 },
+};
+
+export interface PredictionLaunchIntent {
+  venueScope: PredictionVenueScope;
+  categoryId: PredictionCategoryId;
+  browseTab: PredictionBrowseTab;
+  searchQuery: string;
+}
+
+function normalizeArg(value: string): string {
+  return value.trim().toLowerCase();
+}
+
+export function parsePredictionLaunchArgs(
+  args: string[],
+): PredictionLaunchIntent | null {
+  const [command, ...rest] = args;
+  if (!command) return null;
+  const normalizedCommand = normalizeArg(command);
+  if (
+    normalizedCommand !== "predictions" &&
+    normalizedCommand !== "prediction-markets" &&
+    normalizedCommand !== "pm"
+  ) {
+    return null;
+  }
+
+  let venueScope: PredictionVenueScope = "all";
+  let categoryId: PredictionCategoryId = "all";
+  let browseTab: PredictionBrowseTab = "top";
+  let venueExplicit = false;
+  let categoryExplicit = false;
+  let browseExplicit = false;
+  const searchTokens: string[] = [];
+
+  for (const arg of rest) {
+    const normalized = normalizeArg(arg);
+    if (!normalized) continue;
+
+    if (!venueExplicit && VENUE_SCOPE_SET.has(normalized as PredictionVenueScope)) {
+      venueScope = normalized as PredictionVenueScope;
+      venueExplicit = true;
+      continue;
+    }
+    if (!categoryExplicit && CATEGORY_ID_SET.has(normalized as PredictionCategoryId)) {
+      categoryId = normalized as PredictionCategoryId;
+      categoryExplicit = true;
+      continue;
+    }
+    if (!browseExplicit && BROWSE_TAB_SET.has(normalized as PredictionBrowseTab)) {
+      browseTab = normalized as PredictionBrowseTab;
+      browseExplicit = true;
+      continue;
+    }
+    searchTokens.push(arg);
+  }
+
+  return {
+    venueScope,
+    categoryId,
+    browseTab,
+    searchQuery: searchTokens.join(" ").trim(),
+  };
+}
+
+function syncActiveLayout(
+  layouts: SavedLayout[],
+  activeLayoutIndex: number,
+  nextLayout: AppConfig["layout"],
+): SavedLayout[] {
+  return layouts.map((entry, index) => (
+    index === activeLayoutIndex
+      ? { ...entry, layout: cloneLayout(nextLayout) }
+      : { ...entry, layout: cloneLayout(entry.layout) }
+  ));
+}
+
+export function applyPredictionLaunchIntentToConfig(
+  config: AppConfig,
+  intent: PredictionLaunchIntent,
+  terminalSize: { width: number; height: number },
+): { config: AppConfig; paneInstanceId: string } {
+  let nextLayout = cloneLayout(config.layout);
+  let targetInstance =
+    nextLayout.instances.find((instance) => instance.paneId === PREDICTION_PANE_ID) ??
+    null;
+
+  if (!targetInstance) {
+    targetInstance = createPaneInstance(PREDICTION_PANE_ID, {
+      instanceId: PREDICTION_MAIN_INSTANCE_ID,
+      params: {
+        scope: intent.venueScope,
+        category: intent.categoryId,
+        browseTab: intent.browseTab,
+        query: intent.searchQuery,
+      },
+    });
+    nextLayout = addPaneFloating(
+      nextLayout,
+      targetInstance,
+      terminalSize.width,
+      terminalSize.height,
+      PREDICTION_FLOATING_PANE_DEF,
+    );
+  } else {
+    nextLayout = {
+      ...nextLayout,
+      instances: nextLayout.instances.map((instance) => (
+        instance.instanceId === targetInstance!.instanceId
+          ? {
+              ...instance,
+              params: {
+                ...(instance.params ?? {}),
+                scope: intent.venueScope,
+                category: intent.categoryId,
+                browseTab: intent.browseTab,
+                query: intent.searchQuery,
+              },
+            }
+          : instance
+      )),
+    };
+    targetInstance =
+      findPaneInstance(nextLayout, targetInstance.instanceId) ?? targetInstance;
+    if (!targetInstance) {
+      throw new Error("Prediction launch target pane could not be resolved.");
+    }
+    const targetInstanceId = targetInstance.instanceId;
+    if (!isPaneInLayout(nextLayout, targetInstanceId)) {
+      nextLayout = addPaneFloating(
+        nextLayout,
+        targetInstance,
+        terminalSize.width,
+        terminalSize.height,
+        PREDICTION_FLOATING_PANE_DEF,
+      );
+    } else if (
+      nextLayout.floating.some((entry) => entry.instanceId === targetInstanceId)
+    ) {
+      nextLayout = bringToFront(nextLayout, targetInstanceId);
+    }
+  }
+
+  if (!targetInstance) {
+    throw new Error("Prediction launch target pane could not be resolved.");
+  }
+
+  return {
+    config: {
+      ...config,
+      layout: nextLayout,
+      layouts: syncActiveLayout(config.layouts, config.activeLayoutIndex, nextLayout),
+    },
+    paneInstanceId: targetInstance.instanceId,
+  };
+}
+
+export function applyPredictionLaunchIntentToSessionSnapshot(
+  config: AppConfig,
+  sessionSnapshot: AppSessionSnapshot | null,
+  paneInstanceId: string,
+  intent: PredictionLaunchIntent,
+): AppSessionSnapshot {
+  const currentPaneState = sessionSnapshot?.paneState?.[paneInstanceId] ?? {};
+  const currentPluginState =
+    (currentPaneState.pluginState as Record<string, Record<string, unknown>> | undefined) ??
+    {};
+  const currentPredictionState = currentPluginState[PREDICTION_PANE_ID] ?? {};
+
+  return {
+    paneState: {
+      ...(sessionSnapshot?.paneState ?? {}),
+      [paneInstanceId]: {
+        ...currentPaneState,
+        pluginState: {
+          ...currentPluginState,
+          [PREDICTION_PANE_ID]: {
+            ...currentPredictionState,
+            venueScope: intent.venueScope,
+            categoryId: intent.categoryId,
+            browseTab: intent.browseTab,
+            searchQuery: intent.searchQuery,
+            selectedRowKey: null,
+            selectedDetailMarketKey: null,
+          },
+        },
+      },
+    },
+    focusedPaneId: paneInstanceId,
+    activePanel: sessionSnapshot?.activePanel === "right" ? "right" : "left",
+    statusBarVisible: sessionSnapshot?.statusBarVisible !== false,
+    openPaneIds: [
+      ...new Set([
+        ...(sessionSnapshot?.openPaneIds ?? []),
+        ...getDockedPaneIds(config.layout),
+        ...config.layout.floating.map((entry) => entry.instanceId),
+      ]),
+    ],
+    hydrationTargets: [...(sessionSnapshot?.hydrationTargets ?? [])],
+    exchangeCurrencies: [...(sessionSnapshot?.exchangeCurrencies ?? [])],
+    savedAt: Date.now(),
+  };
+}