gloomberb 0.11.2 → 0.12.0

package/src/plugins/builtin/options/view.tsx

@@ -3,6 +3,7 @@ import { Box, Text } from "../../../ui";
 import { usePaneSettingValue, usePaneTicker } from "../../../state/app/context";
 import { colors } from "../../../theme/colors";
 import { isPlainKey } from "../../../utils/keyboard";
+import { formatCompact } from "../../../utils/format";
 import { formatExpDate, resolveOptionsTarget } from "../../../utils/options";
 import { useOptionsQuery, useResolvedEntryValue, useTickerFinancials } from "../../../market-data/hooks";
 import {
@@ -21,15 +22,19 @@ import {
   type OptionSide,
 } from "../options-calculator/model";
 import { buildChainCalcParams, resolveCalcSide } from "./calc-seed";
+import { calculateOptionGreeks, calculateOptionsSummary, type OptionsSummary } from "./analytics";
 import {
-  OPTION_COLUMNS,
+  DEFAULT_OPTION_FIELD_IDS,
   buildStrikeList,
+  createOptionColumns,
   findNearestStrikeIndex,
+  formatIv,
   optionColumnColor,
   renderOptionCell,
   resolveDefaultStrikeTarget,
+  resolveOptionFieldIds,
 } from "./table";
-import type { OptionColumn, OptionTableRow, OptionsViewProps } from "./types";
+import type { OptionColumn, OptionFieldId, OptionTableRow, OptionsViewProps } from "./types";
 import {
   buildOptionQuoteTargets,
   overlayOptionRowQuotes,
@@ -39,6 +44,48 @@ import {
 import { useOptionsAccessFooter } from "./footer";
 import { useLiveStreamingSetting } from "../shared/live-streaming";
 
+type SummaryMetric = { label: string; value: string };
+
+function formatRatio(value: number | null | undefined): string {
+  return value == null || !Number.isFinite(value) ? "—" : value.toFixed(2);
+}
+
+function SummaryRow({ metrics }: { metrics: SummaryMetric[] }) {
+  return (
+    <Box flexDirection="row" height={1} gap={3} overflow="hidden">
+      {metrics.map((metric) => (
+        <Box key={metric.label} flexDirection="row" flexShrink={0}>
+          <Text fg={colors.textDim}>{`${metric.label} `}</Text>
+          <Text fg={colors.textBright}>{metric.value}</Text>
+        </Box>
+      ))}
+    </Box>
+  );
+}
+
+function OptionsSummaryStrip({ summary, secondary }: {
+  summary: OptionsSummary | null;
+  secondary: boolean;
+}) {
+  const volatility: SummaryMetric[] = [
+    { label: "ATM IV", value: formatIv(summary?.atmImpliedVolatility ?? undefined) },
+    { label: "HV30", value: formatIv(summary?.historicalVolatility30d ?? undefined) },
+    { label: "IV/HV", value: formatRatio(summary?.impliedHistoricalRatio) },
+  ];
+  return (
+    <Box flexDirection="column" height={secondary ? 2 : 1}>
+      <SummaryRow metrics={volatility} />
+      {secondary && (
+        <SummaryRow metrics={[
+          { label: "EXP VOL", value: summary ? formatCompact(summary.expirationVolume) : "—" },
+          { label: "P/C VOL", value: formatRatio(summary?.putCallVolumeRatio) },
+          { label: "P/C OI", value: formatRatio(summary?.putCallOpenInterestRatio) },
+        ]} />
+      )}
+    </Box>
+  );
+}
+
 export function OptionsView({ width, height, focused, onCapture = () => {} }: OptionsViewProps) {
   const { ticker, financials } = usePaneTicker();
   const { createPaneFromTemplate } = usePluginAppActions();
@@ -61,6 +108,9 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
   const effectiveTicker = target?.effectiveTicker ?? "";
   const effectiveExchange = target?.effectiveExchange ?? "";
   const underlyingFinancials = useTickerFinancials(isOpt ? effectiveTicker : null, null);
+  const underlying = isOpt ? underlyingFinancials : financials;
+  const spot = underlying?.quote?.price;
+  const dividendYield = underlying?.fundamentals?.dividendYield;
   const instrument = target?.instrument ?? null;
   const baseRequest = target
     ? {
@@ -74,6 +124,8 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     }
     : null;
   const [chainRefreshMinutes] = usePaneSettingValue<string>("chainRefreshMinutes", "");
+  const [storedOptionFieldIds] = usePaneSettingValue<OptionFieldId[]>("optionColumnIds", DEFAULT_OPTION_FIELD_IDS);
+  const optionFieldIds = useMemo(() => resolveOptionFieldIds(storedOptionFieldIds), [storedOptionFieldIds]);
   const initialChainEntry = useOptionsQuery(baseRequest);
   const initialChain = useResolvedEntryValue(initialChainEntry);
   const selectedExpiration = initialChain?.expirationDates[expIdx];
@@ -157,12 +209,27 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     () => new Map(strikeChain?.puts.map((p) => [p.strike, p]) ?? []),
     [strikeChain],
   );
-  const snapshotRows = useMemo<OptionTableRow[]>(() => strikes.map((strike) => ({
-    strike,
-    call: callsByStrike.get(strike),
-    put: putsByStrike.get(strike),
-    isPositionStrike: !!parsed && Math.abs(strike - parsed.strike) < 0.01,
-  })), [callsByStrike, parsed, putsByStrike, strikes]);
+  const snapshotRows = useMemo<OptionTableRow[]>(() => {
+    const now = Date.now();
+    return strikes.map((strike) => {
+      const call = callsByStrike.get(strike);
+      const put = putsByStrike.get(strike);
+      return {
+        strike,
+        call,
+        put,
+        callGreeks: calculateOptionGreeks(call, "call", spot, dividendYield, now),
+        putGreeks: calculateOptionGreeks(put, "put", spot, dividendYield, now),
+        isPositionStrike: !!parsed && Math.abs(strike - parsed.strike) < 0.01,
+      };
+    });
+  }, [callsByStrike, dividendYield, parsed, putsByStrike, spot, strikes]);
+  const summary = useMemo(
+    () => strikeChain
+      ? calculateOptionsSummary(strikeChain, spot, underlying?.priceHistory ?? [])
+      : null,
+    [spot, strikeChain, underlying?.priceHistory],
+  );
   const visibleStrikeRange = visibleStrikeViewport?.key === viewportKey
     ? visibleStrikeViewport.range
     : null;
@@ -210,10 +277,10 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     ),
     [optionQuoteEntries, optionQuoteFreshness, optionQuoteTargets],
   );
-  const optionColumns: OptionColumn[] = OPTION_COLUMNS.map((column) => ({
+  const optionColumns = useMemo<OptionColumn[]>(() => createOptionColumns(optionFieldIds).map((column) => ({
     ...column,
-    headerColor: optionColumnColor(column.id, colors.panel),
-  }));
+    headerColor: optionColumnColor(column, colors.panel),
+  })), [optionFieldIds]);
 
   const selectedRow = rows[strikeIdx] ?? null;
   const calcParams = useMemo(() => buildChainCalcParams({
@@ -222,9 +289,9 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     side: resolveCalcSide(calcSide, parsed?.side, selectedRow),
     // On an option ticker the pane quote is the contract's own price, so load
     // the underlying snapshot rather than silently using the option mark as spot.
-    spot: (isOpt ? underlyingFinancials : financials)?.quote?.price,
-    dividendYield: (isOpt ? underlyingFinancials : financials)?.fundamentals?.dividendYield,
-  }), [calcSide, effectiveTicker, financials, isOpt, parsed?.side, selectedRow, underlyingFinancials]);
+    spot,
+    dividendYield,
+  }), [calcSide, dividendYield, effectiveTicker, parsed?.side, selectedRow, spot]);
 
   const openCalculator = useCallback(() => {
     if (!calcParams) return;
@@ -243,10 +310,10 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     rowState: { selected: boolean },
   ) => {
     const cell = renderOptionCell(row, column, index, rowState);
-    if (column.id === "strike") return cell;
+    if (!column.side) return cell;
     // Clicking a call or put cell is the mouse way to choose which contract
     // [c]alc opens, so it has to select the row itself as well.
-    const side: OptionSide = column.id.startsWith("call") ? "call" : "put";
+    const side: OptionSide = column.side;
     return {
       ...cell,
       onMouseDown: () => {
@@ -277,12 +344,12 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
 
   useEffect(() => {
     if (strikes.length === 0 || userSelectedStrikeRef.current) return;
-    const targetStrike = resolveDefaultStrikeTarget(parsed?.strike, financials?.quote?.price);
+    const targetStrike = resolveDefaultStrikeTarget(parsed?.strike, spot);
     if (targetStrike == null) return;
     setScrollToIndexAlign("center");
     setStrikeIdx(findNearestStrikeIndex(strikes, targetStrike));
     setAutoScrollVersion((version) => version + 1);
-  }, [expIdx, financials?.quote?.price, parsed?.strike, strikes]);
+  }, [expIdx, parsed?.strike, spot, strikes]);
 
   useShortcut((event) => {
     if (event.defaultPrevented || event.propagationStopped || event.targetEditable) return;
@@ -356,25 +423,6 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
       return true;
     }
 
-    if (isPlainKey(event, "j", "down")) {
-      if (strikes.length === 0) return true;
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      userSelectedStrikeRef.current = true;
-      setScrollToIndexAlign("nearest");
-      setStrikeIdx((i) => Math.min(i + 1, strikes.length - 1));
-      return true;
-    }
-    if (isPlainKey(event, "k", "up")) {
-      if (strikes.length === 0) return true;
-      event.preventDefault?.();
-      event.stopPropagation?.();
-      userSelectedStrikeRef.current = true;
-      setScrollToIndexAlign("nearest");
-      setStrikeIdx((i) => Math.max(i - 1, 0));
-      return true;
-    }
-
     return false;
   }, [
     calcParams,
@@ -383,7 +431,6 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     interactive,
     openCalculator,
     selectAdjacentExpiration,
-    strikes.length,
   ]);
 
   if (!ticker) {
@@ -399,13 +446,18 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     ? ticker.metadata.positions.reduce((sum, p) => sum + p.shares, 0)
     : 0;
   const expirationTabsWidth = Math.max(width - 9 - (loading ? 2 : 0), 8);
-  const tableHeight = Math.max(1, height - 1 - (isOpt && parsed ? 1 : 0));
+  const summaryRowCount = height >= 10 ? 2 : height >= 7 ? 1 : 0;
+  const tableHeight = Math.max(1, height - 1 - summaryRowCount - (isOpt && parsed ? 1 : 0));
   // The strip scrolls; without a marker a clipped last date reads as the last expiry.
   const expirationStripOverflows = chain.expirationDates
     .reduce((total, ts) => total + formatExpDate(ts).length + 2, 0) > expirationTabsWidth;
 
   return (
     <Box flexDirection="column" flexGrow={1} paddingX={1} onMouseDown={() => { if (!interactive) enterInteractive(); }}>
+      {summaryRowCount > 0 && (
+        <OptionsSummaryStrip summary={summary} secondary={summaryRowCount > 1} />
+      )}
+
       <Box flexDirection="row" height={1} gap={1}>
         <Text fg={colors.textDim}>Exp:</Text>
         <Box width={expirationTabsWidth} height={1} overflow="hidden">
@@ -450,11 +502,10 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
             setStrikeIdx(index);
           },
         }}
-        onCursorChange={(_row, index) => {
+        onCursorChange={() => {
           userSelectedStrikeRef.current = true;
           setScrollToIndexAlign("nearest");
           enterInteractive();
-          setStrikeIdx(index);
         }}
         onRootKeyDown={handleTableKeyDown}
         headerScrollId="options-table-header-scroll"

package/src/plugins/builtin/plugin-marketplace/feed.ts

@@ -0,0 +1,80 @@
+import { createThrottledFetch } from "../../../utils/throttled-fetch";
+import type { RegistryFeed, RegistryPlugin } from "./model";
+
+/**
+ * Exported so the hosted build's CSP can be checked against it. The browser
+ * renderer can only reach origins listed in `connect-src`, and a blocked fetch
+ * shows up as an empty catalog rather than an error, so the two are pinned
+ * together by a test.
+ */
+export const REGISTRY_ORIGIN = "https://plugins.gloom.sh";
+const REGISTRY_URL = `${REGISTRY_ORIGIN}/registry.json`;
+const FRESH_MS = 15 * 60_000;
+
+const registryFetch = createThrottledFetch({
+  requestsPerMinute: 20,
+  maxRetries: 2,
+  timeoutMs: 10_000,
+  backoffBaseMs: 500,
+  dedupeGetRequests: true,
+  defaultHeaders: { Accept: "application/json" },
+});
+
+interface CacheEntry {
+  plugins: RegistryPlugin[];
+  fetchedAt: number;
+}
+
+let cache: CacheEntry | null = null;
+let inFlight: Promise<RegistryPlugin[]> | null = null;
+
+export interface FeedResult {
+  plugins: RegistryPlugin[];
+  fetchedAt: number | null;
+  /** Served from cache after a failed refresh. */
+  stale: boolean;
+  error: string | null;
+}
+
+function parseFeed(body: unknown): RegistryPlugin[] {
+  const feed = body as RegistryFeed | null;
+  if (!feed || !Array.isArray(feed.plugins)) throw new Error("Malformed registry feed");
+  // Only fields the pane actually reads are required; the rest degrade to defaults
+  // so a feed built by a newer registry version still renders.
+  return feed.plugins.filter((plugin): plugin is RegistryPlugin => (
+    !!plugin && typeof plugin.id === "string" && typeof plugin.name === "string"
+  ));
+}
+
+export async function loadRegistry(options: { force?: boolean } = {}): Promise<FeedResult> {
+  const now = Date.now();
+  if (!options.force && cache && now - cache.fetchedAt < FRESH_MS) {
+    return { plugins: cache.plugins, fetchedAt: cache.fetchedAt, stale: false, error: null };
+  }
+
+  if (!inFlight) {
+    inFlight = (async () => {
+      const response = await registryFetch.fetch(REGISTRY_URL);
+      if (!response.ok) throw new Error(`Registry request failed (${response.status})`);
+      return parseFeed(await response.json());
+    })().finally(() => {
+      inFlight = null;
+    });
+  }
+
+  try {
+    const plugins = await inFlight;
+    cache = { plugins, fetchedAt: Date.now() };
+    return { plugins, fetchedAt: cache.fetchedAt, stale: false, error: null };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    // A stale catalog is far more useful than an empty pane, and the footer
+    // says which one the user is looking at.
+    if (cache) return { plugins: cache.plugins, fetchedAt: cache.fetchedAt, stale: true, error: message };
+    return { plugins: [], fetchedAt: null, stale: false, error: message };
+  }
+}
+
+export function registryPluginUrl(id: string): string {
+  return `https://gloom.sh/plugins/${id}`;
+}

package/src/plugins/builtin/plugin-marketplace/index.tsx

@@ -0,0 +1,31 @@
+import type { PluginModule } from "../plugin-module";
+import { PluginMarketplacePane, PLUGIN_MARKETPLACE_PANE_ID } from "./pane";
+
+export { PLUGIN_MARKETPLACE_PANE_ID } from "./pane";
+export { setMarketplaceHost } from "./store";
+
+export const pluginMarketplaceModule: PluginModule = {
+  panes: [
+    {
+      id: PLUGIN_MARKETPLACE_PANE_ID,
+      name: "Plugins",
+      icon: "P",
+      component: PluginMarketplacePane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 118, height: 34 },
+    },
+  ],
+
+  paneTemplates: [
+    {
+      id: "plugin-marketplace-pane",
+      paneId: PLUGIN_MARKETPLACE_PANE_ID,
+      label: "Plugins",
+      description: "Browse and install Gloomberb plugins, and enable or disable the ones you have.",
+      keywords: ["plugin", "plugins", "marketplace", "install", "extend", "addon", "extension"],
+      shortcut: { prefix: "PL" },
+      createInstance: () => ({ placement: "floating" }),
+    },
+  ],
+};

package/src/plugins/builtin/plugin-marketplace/model.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  collectCategories,
+  isInstallable,
+  mergeCatalog,
+  sortEntries,
+  unsupportedLabel,
+  type InstalledPlugin,
+  type RegistryPlugin,
+} from "./model";
+
+function registryPlugin(overrides: Partial<RegistryPlugin> & Pick<RegistryPlugin, "id">): RegistryPlugin {
+  return {
+    name: overrides.id,
+    repo: `gloom-sh/${overrides.id}`,
+    tagline: "",
+    author: { name: "Someone" },
+    categories: ["data"],
+    targets: ["cli", "tui", "desktop", "web"],
+    hosts: [],
+    contributes: { panes: [], capabilities: [], broker: false },
+    tier: "community",
+    bundled: false,
+    stars: 0,
+    ...overrides,
+  };
+}
+
+function installedPlugin(overrides: Partial<InstalledPlugin> & Pick<InstalledPlugin, "id">): InstalledPlugin {
+  return {
+    name: overrides.id,
+    version: "1.0.0",
+    toggleable: true,
+    enabled: true,
+    source: "external",
+    ...overrides,
+  };
+}
+
+/**
+ * The merge is the only real logic in this pane, and it reconciles three
+ * sources that disagree during normal use. Each case below is a state a user
+ * can actually reach, and getting one wrong either hides a plugin they have
+ * installed or offers an install button for something already present.
+ */
+describe("mergeCatalog", () => {
+  test("marks a bundled plugin installed even when the local catalog has not reported it", () => {
+    // Happens whenever the feed ships an entry before the user upgrades.
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "gloomberb-cloud", bundled: true, tier: "official" })],
+      installed: [],
+      target: "tui",
+    });
+
+    expect(entry?.installed).toBe(true);
+    expect(entry?.enabled).toBe(true);
+  });
+
+  test("takes enabled state from the local catalog, not the registry", () => {
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "hackernews" })],
+      installed: [installedPlugin({ id: "hackernews", enabled: false, version: "0.2.0" })],
+      target: "tui",
+    });
+
+    expect(entry?.installed).toBe(true);
+    expect(entry?.enabled).toBe(false);
+    expect(entry?.installedVersion).toBe("0.2.0");
+  });
+
+  test("keeps a side-loaded plugin the registry has never seen", () => {
+    const entries = mergeCatalog({
+      registry: [registryPlugin({ id: "hackernews" })],
+      installed: [installedPlugin({ id: "my-private-plugin" })],
+      target: "tui",
+    });
+
+    const sideloaded = entries.find((entry) => entry.id === "my-private-plugin");
+    expect(sideloaded?.installed).toBe(true);
+    expect(sideloaded?.categories).toEqual(["unlisted"]);
+  });
+
+  test("flags a plugin the current renderer cannot run without calling it uninstalled", () => {
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "ibkr-gateway", targets: ["cli", "tui", "desktop"] })],
+      installed: [installedPlugin({ id: "ibkr-gateway" })],
+      target: "web",
+    });
+
+    expect(entry?.installed).toBe(true);
+    expect(entry?.unsupportedHere).toBe(true);
+    expect(unsupportedLabel(entry!)).toBe("Desktop only");
+  });
+
+  test("does not flag a plugin that supports the current renderer", () => {
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "hackernews" })],
+      installed: [],
+      target: "web",
+    });
+
+    expect(entry?.unsupportedHere).toBe(false);
+    expect(unsupportedLabel(entry!)).toBeNull();
+  });
+
+  test("surfaces a load error so a broken install is visible rather than missing", () => {
+    const [entry] = mergeCatalog({
+      registry: [registryPlugin({ id: "broken" })],
+      installed: [installedPlugin({ id: "broken", loadError: "SyntaxError" })],
+      target: "tui",
+    });
+
+    expect(entry?.loadError).toBe("SyntaxError");
+  });
+});
+
+describe("sortEntries", () => {
+  test("puts what is installed above the rest of the catalog", () => {
+    // One list rather than two tabs: acting on what you already have should not
+    // require a mode switch, and an uninstalled plugin should never outrank one
+    // that is present just because it has more stars.
+    const entries = mergeCatalog({
+      registry: [
+        registryPlugin({ id: "popular-uninstalled", tier: "official", stars: 5000 }),
+        registryPlugin({ id: "quiet-installed", tier: "community", stars: 0 }),
+      ],
+      installed: [installedPlugin({ id: "quiet-installed" })],
+      target: "tui",
+    });
+
+    expect(sortEntries(entries).map((entry) => entry.id))
+      .toEqual(["quiet-installed", "popular-uninstalled"]);
+  });
+
+  test("puts the featured plugin first, then tier, then stars", () => {
+    const entries = mergeCatalog({
+      registry: [
+        registryPlugin({ id: "community-popular", tier: "community", stars: 900 }),
+        registryPlugin({ id: "official-quiet", tier: "official", stars: 2 }),
+        registryPlugin({ id: "cloud", tier: "official", featured: true, bundled: true, stars: 0 }),
+        registryPlugin({ id: "verified-mid", tier: "verified", stars: 50 }),
+      ],
+      installed: [],
+      target: "tui",
+    });
+
+    // All uninstalled, so the curated order applies within that half.
+    expect(sortEntries(entries).map((entry) => entry.id)).toEqual([
+      "cloud",
+      "official-quiet",
+      "verified-mid",
+      "community-popular",
+    ]);
+  });
+});
+
+describe("collectCategories", () => {
+  test("deduplicates and sorts categories across the catalog", () => {
+    const entries = mergeCatalog({
+      registry: [
+        registryPlugin({ id: "a", categories: ["news", "data"] }),
+        registryPlugin({ id: "b", categories: ["data"] }),
+      ],
+      installed: [],
+      target: "tui",
+    });
+
+    expect(collectCategories(entries)).toEqual(["data", "news"]);
+  });
+});
+
+describe("isInstallable", () => {
+  test("offers an install only for a catalog plugin that is absent", () => {
+    const [available, bundled, installed] = mergeCatalog({
+      registry: [
+        registryPlugin({ id: "available" }),
+        registryPlugin({ id: "bundled", bundled: true }),
+        registryPlugin({ id: "installed" }),
+      ],
+      installed: [installedPlugin({ id: "installed" })],
+      target: "tui",
+    });
+
+    expect(isInstallable(available!)).toBe(true);
+    // Ships with the app; there is nothing to fetch.
+    expect(isInstallable(bundled!)).toBe(false);
+    expect(isInstallable(installed!)).toBe(false);
+  });
+
+  test("does not offer an install without a repository to clone", () => {
+    const [entry] = mergeCatalog({
+      registry: [],
+      installed: [installedPlugin({ id: "sideloaded" })],
+      target: "tui",
+    });
+
+    expect(isInstallable(entry!)).toBe(false);
+  });
+});