gloomberb 0.3.3 → 0.4.0

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

@@ -7,7 +7,7 @@ import {
   type AppConfig,
   type SavedLayout,
 } from "../../types/config";
-import type { PaneDef } from "../../types/plugin";
+import type { CliLaunchRequest, PaneDef } from "../../types/plugin";
 import type { AppSessionSnapshot } from "../../state/session-persistence";
 import { PREDICTION_CATEGORY_OPTIONS, type PredictionCategoryId } from "./categories";
 import { BROWSE_TABS } from "./navigation";
@@ -48,20 +48,7 @@ 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;
-  }
-
+export function parsePredictionCommandArgs(args: string[]): PredictionLaunchIntent {
   let venueScope: PredictionVenueScope = "all";
   let categoryId: PredictionCategoryId = "all";
   let browseTab: PredictionBrowseTab = "top";
@@ -70,7 +57,7 @@ export function parsePredictionLaunchArgs(
   let browseExplicit = false;
   const searchTokens: string[] = [];
 
-  for (const arg of rest) {
+  for (const arg of args) {
     const normalized = normalizeArg(arg);
     if (!normalized) continue;
 
@@ -100,6 +87,23 @@ export function parsePredictionLaunchArgs(
   };
 }
 
+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;
+  }
+
+  return parsePredictionCommandArgs(rest);
+}
+
 function syncActiveLayout(
   layouts: SavedLayout[],
   activeLayoutIndex: number,
@@ -238,3 +242,34 @@ export function applyPredictionLaunchIntentToSessionSnapshot(
     savedAt: Date.now(),
   };
 }
+
+export function createPredictionLaunchRequest(
+  intent: PredictionLaunchIntent,
+): CliLaunchRequest<{ paneInstanceId: string; intent: PredictionLaunchIntent }> {
+  return {
+    applyConfig(config, env) {
+      const result = applyPredictionLaunchIntentToConfig(config, intent, {
+        width: Math.max(env.terminalWidth, 120),
+        height: Math.max(env.terminalHeight, 40),
+      });
+      return {
+        config: result.config,
+        launchState: {
+          paneInstanceId: result.paneInstanceId,
+          intent,
+        },
+      };
+    },
+    applySessionSnapshot(config, snapshot, launchState) {
+      if (!launchState) {
+        return applyPredictionLaunchIntentToSessionSnapshot(config, snapshot, PREDICTION_MAIN_INSTANCE_ID, intent);
+      }
+      return applyPredictionLaunchIntentToSessionSnapshot(
+        config,
+        snapshot,
+        launchState.paneInstanceId,
+        launchState.intent,
+      );
+    },
+  };
+}

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

@@ -170,13 +170,17 @@ export function getNextPredictionSort(
   current: PredictionSortPreference,
   columnId: string,
 ): PredictionSortPreference {
+  const initialDirection =
+    columnId === "ends" || TEXT_SORT_COLUMNS.has(columnId) ? "asc" : "desc";
+  const alternateDirection = initialDirection === "asc" ? "desc" : "asc";
+
   if (current.columnId !== columnId) {
-    if (columnId === "ends") return { columnId, direction: "asc" };
-    if (TEXT_SORT_COLUMNS.has(columnId)) return { columnId, direction: "asc" };
-    return { columnId, direction: "desc" };
+    return { columnId, direction: initialDirection };
+  }
+  if (current.direction === initialDirection) {
+    return { columnId, direction: alternateDirection };
   }
-  if (current.direction === "desc") return { columnId, direction: "asc" };
-  return { columnId: null, direction: "desc" };
+  return { columnId: null, direction: initialDirection };
 }
 
 export function filterPredictionMarkets(

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

@@ -83,14 +83,15 @@ describe("prediction markets pane interactions", () => {
     expect(frame).toContain("Will the Fed cut rates?");
   });
 
-  test("renders the merged market browser and supports venue switching", async () => {
+  test("selects a market on single click and opens detail on double click", async () => {
     installPredictionMarketMocks();
 
     testSetup = await testRender(<Harness />, { width: 120, height: 34 });
     await flushFrames(testSetup);
 
     let frame = testSetup.captureCharFrame();
-    expect(frame).toContain("Prediction Markets");
+    expect(frame).toContain("All venues");
+    expect(frame).not.toContain("VOL = native venue units");
     expect(frame).toContain("Will inflation fall?");
     expect(frame).toContain("Kalshi");
 
@@ -114,10 +115,60 @@ describe("prediction markets pane interactions", () => {
 
     frame = testSetup.captureCharFrame();
     expect(frame).toContain("Will the Fed cut rates?");
+    expect(frame).not.toContain("Kalshi primary rule");
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(kalshiCol + 1, kalshiRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup);
+
+    frame = testSetup.captureCharFrame();
     expect(frame).toContain("Kalshi primary rule");
   });
 
-  test("moves selection through the list with keyboard navigation", async () => {
+  test("loads selected detail once instead of refetching in a render loop", async () => {
+    const { fetchUrls } = installPredictionMarketMocks();
+
+    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
+    await flushFrames(testSetup);
+
+    const frame = testSetup.captureCharFrame();
+    const lines = frame.split("\n");
+    const kalshiRow = lines.findIndex((line) =>
+      line.includes("Will the Fed cut rates?"),
+    );
+    const kalshiCol = lines[kalshiRow]?.indexOf("Will the Fed cut rates?") ?? -1;
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(kalshiCol + 1, kalshiRow);
+      await testSetup!.renderOnce();
+      await testSetup!.mockMouse.click(kalshiCol + 1, kalshiRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup, 8);
+
+    const eventFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/events/FED-1"),
+    );
+    const orderbookFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/markets/KAL-1/orderbook"),
+    );
+    const tradeFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/markets/trades?ticker=KAL-1"),
+    );
+    const historyFetches = fetchUrls.filter((url) =>
+      url.includes("/trade-api/v2/series/FED/markets/KAL-1/candlesticks"),
+    );
+
+    expect(eventFetches).toHaveLength(2);
+    expect(orderbookFetches).toHaveLength(1);
+    expect(tradeFetches).toHaveLength(1);
+    expect(historyFetches).toHaveLength(1);
+    expect(testSetup.captureCharFrame()).not.toContain("Loading market detail...");
+  });
+
+  test("moves selection through the list with keyboard navigation without opening detail", async () => {
     installPredictionMarketMocks();
 
     testSetup = await testRender(<Harness />, { width: 120, height: 34 });
@@ -136,6 +187,102 @@ describe("prediction markets pane interactions", () => {
 
     const frame = testSetup.captureCharFrame();
     expect(frame).toContain("Will the Fed cut rates?");
+    expect(frame).not.toContain("Kalshi primary rule");
+    expect(frame).not.toContain("<- Back");
+  });
+
+  test("keeps a clicked header sort instead of snapping back to the default sort", async () => {
+    installPredictionMarketMocks();
+
+    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
+    await flushFrames(testSetup);
+
+    const frame = testSetup.captureCharFrame();
+    const lines = frame.split("\n");
+    const headerRow = lines.findIndex((line) => line.includes("VENUE"));
+    const headerCol = lines[headerRow]?.indexOf("VENUE") ?? -1;
+
+    expect(headerRow).toBeGreaterThan(-1);
+    expect(headerCol).toBeGreaterThan(-1);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(headerCol + 1, headerRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup, 4);
+
+    const nextFrame = testSetup.captureCharFrame();
+    const nextLines = nextFrame.split("\n");
+    const kalshiRow = nextLines.findIndex((line) =>
+      line.includes("Will the Fed cut rates?"),
+    );
+    const polymarketRow = nextLines.findIndex((line) =>
+      line.includes("Will inflation fall?"),
+    );
+
+    expect(
+      harnessStateRef.current?.paneState[TEST_PANE_ID]?.pluginState?.[
+        "prediction-markets"
+      ]?.sortPreference,
+    ).toEqual({ columnId: "venue", direction: "asc" });
+    expect(nextLines[headerRow]).toContain("VENUE ▲");
+    expect(kalshiRow).toBeGreaterThan(-1);
+    expect(polymarketRow).toBeGreaterThan(-1);
+    expect(kalshiRow).toBeLessThan(polymarketRow);
+  });
+
+  test("cycles the ends header through reverse date order before resetting", async () => {
+    installPredictionMarketMocks();
+
+    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
+    await flushFrames(testSetup);
+
+    const frame = testSetup.captureCharFrame();
+    const lines = frame.split("\n");
+    const headerRow = lines.findIndex((line) => line.includes("ENDS"));
+    const headerCol = lines[headerRow]?.indexOf("ENDS") ?? -1;
+
+    expect(headerRow).toBeGreaterThan(-1);
+    expect(headerCol).toBeGreaterThan(-1);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(headerCol + 1, headerRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup, 2);
+
+    const sortedFrame = testSetup.captureCharFrame();
+    const sortedLines = sortedFrame.split("\n");
+    const sortedHeaderRow = sortedLines.findIndex((line) => line.includes("ENDS"));
+    const sortedHeaderCol = sortedLines[sortedHeaderRow]?.indexOf("ENDS") ?? -1;
+
+    expect(sortedHeaderRow).toBeGreaterThan(-1);
+    expect(sortedHeaderCol).toBeGreaterThan(-1);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(sortedHeaderCol + 1, sortedHeaderRow);
+      await testSetup!.renderOnce();
+    });
+    await flushFrames(testSetup, 4);
+
+    const nextFrame = testSetup.captureCharFrame();
+    const nextLines = nextFrame.split("\n");
+    const kalshiRow = nextLines.findIndex((line) =>
+      line.includes("Will the Fed cut rates?"),
+    );
+    const polymarketRow = nextLines.findIndex((line) =>
+      line.includes("Will inflation fall?"),
+    );
+
+    expect(
+      harnessStateRef.current?.paneState[TEST_PANE_ID]?.pluginState?.[
+        "prediction-markets"
+      ]?.sortPreference,
+    ).toEqual({ columnId: "ends", direction: "desc" });
+    expect(nextLines[headerRow]).toContain("ENDS ▼");
+    expect(kalshiRow).toBeGreaterThan(-1);
+    expect(polymarketRow).toBeGreaterThan(-1);
+    expect(kalshiRow).toBeLessThan(polymarketRow);
   });
 
   test("does not wrap to the last row when moving up without a selection", async () => {
@@ -157,7 +304,7 @@ describe("prediction markets pane interactions", () => {
     ).toBe("polymarket:pm-1");
   });
 
-  test("supports detail outcome navigation and escape focus return from the keyboard", async () => {
+  test("supports detail outcome navigation and backspace return from the keyboard", async () => {
     attachPredictionMarketsPersistence(new MemoryPersistence());
 
     globalThis.fetch = (async (input: Request | string | URL) => {
@@ -286,17 +433,15 @@ describe("prediction markets pane interactions", () => {
       ]?.selectedDetailMarketKey,
     ).toBe("kalshi:KXFED-27APR-T4.50");
 
-    await emitKeypress(testSetup, { name: "esc", sequence: "\u001b" });
+    await emitKeypress(testSetup, { name: "backspace", sequence: "\u007f" });
     await flushFrames(testSetup);
 
-    expect(
-      harnessStateRef.current?.paneState[TEST_PANE_ID]?.pluginState?.[
-        "prediction-markets"
-      ]?.focusRegion,
-    ).toBe("list");
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("search markets");
+    expect(frame).not.toContain("Rule 2");
   });
 
-  test("starts with no detail pane and toggles the detail pane off on repeat selection", async () => {
+  test("opens full-page detail from a row double click and preserves the browse selection", async () => {
     installPredictionMarketMocks();
 
     testSetup = await testRender(<Harness />, { width: 120, height: 34 });
@@ -312,62 +457,19 @@ describe("prediction markets pane interactions", () => {
     await act(async () => {
       await testSetup!.mockMouse.click(kalshiCol + 1, kalshiRow);
       await testSetup!.renderOnce();
-    });
-    await flushFrames(testSetup);
-
-    await act(async () => {
       await testSetup!.mockMouse.click(kalshiCol + 1, kalshiRow);
       await testSetup!.renderOnce();
     });
     await flushFrames(testSetup);
 
+    const detailFrame = testSetup.captureCharFrame();
+    expect(detailFrame).toContain("<- Back");
+    expect(detailFrame).toContain("Kalshi primary rule");
     expect(
       harnessStateRef.current?.paneState[TEST_PANE_ID]?.pluginState?.[
         "prediction-markets"
       ]?.selectedRowKey,
-    ).toBeNull();
-  });
-
-  test("resizes the list/detail split by dragging the divider", async () => {
-    installPredictionMarketMocks();
-
-    testSetup = await testRender(<Harness />, { width: 120, height: 34 });
-    await flushFrames(testSetup);
-
-    let frame = testSetup.captureCharFrame();
-    const lines = frame.split("\n");
-    const kalshiRow = lines.findIndex((line) =>
-      line.includes("Will the Fed cut rates?"),
-    );
-    const kalshiCol = lines[kalshiRow]?.indexOf("Will the Fed cut rates?") ?? -1;
-
-    await act(async () => {
-      await testSetup!.mockMouse.click(kalshiCol + 1, kalshiRow);
-      await testSetup!.renderOnce();
-    });
-    await flushFrames(testSetup);
-
-    frame = testSetup.captureCharFrame();
-    const dividerLines = frame.split("\n");
-    const dividerRow = dividerLines.findIndex((line) => line.includes("│"));
-    const dividerCol = dividerLines[dividerRow]?.indexOf("│") ?? -1;
-
-    await act(async () => {
-      await testSetup!.mockMouse.drag(
-        dividerCol,
-        dividerRow,
-        dividerCol + 10,
-        dividerRow,
-      );
-      await testSetup!.renderOnce();
-    });
-    await flushFrames(testSetup);
-
-    expect(
-      harnessStateRef.current?.paneState[TEST_PANE_ID]?.pluginState?.[
-        "prediction-markets"
-      ]?.detailSplitRatio,
-    ).toBeGreaterThan(0.42);
+    ).toBe("kalshi:KAL-1");
   });
 
   test("switches categories with arrows and venues with shift+arrows", async () => {