gloomberb 0.16.4 → 0.16.6

package/src/plugins/builtin/alerts/index.tsx

@@ -1,8 +1,20 @@
 import { startCatalystAlerts } from "./catalysts";
 import { RESEARCH_LABELS, researchWizardFields, createResearchAlert } from "./research-builder";
-import { isResearchAlertKind } from "./research-rules";
+import { newYorkToday } from "../earnings/board-model";
+import { checkScheduledEventAlertsNow, startScheduledEventAlerts } from "./scheduled-check";
+import { scheduledEventSources } from "./scheduled-sources";
+import {
+  eventDateUnavailableMessage,
+  lookupScheduledDates,
+  noUpcomingEventMessage,
+  parseLeadDays,
+  readScheduledRule,
+  scheduledTargetKey,
+} from "./scheduled";
+import { isResearchAlertKind, MAX_LEAD_DAYS } from "./research-rules";
 import { EVENT_ALERTS_KEY, EVENT_ALERT_TEMPLATES, MAX_EVENT_ALERTS, createEventAlert, readEventAlerts } from "./events";
 import { formatMarketPrice } from "../../../market-data/market/format";
+import { settleTypedListingKey } from "../../../tickers/listing-venues";
 import type { Quote } from "../../../types/financials";
 import type { GloomPlugin } from "../../../types/plugin";
 import {
@@ -31,6 +43,7 @@ import { createAlertQuoteStream, readStreamedAlertQuote, type AlertQuoteStream }
 import type { AlertRule } from "./types";
 
 let catalystAlertsStop: (() => void) | null = null;
+let scheduledAlertsStop: (() => void) | null = null;
 let pollGeneration = 0;
 let pollTimer: ReturnType<typeof setTimeout> | null = null;
 let alertStream: AlertQuoteStream | null = null;
@@ -54,10 +67,13 @@ export const alertsPlugin: GloomPlugin = {
     const generation = ++pollGeneration;
     catalystAlertsStop?.();
     catalystAlertsStop = startCatalystAlerts(ctx);
+    scheduledAlertsStop?.();
+    scheduledAlertsStop = startScheduledEventAlerts(ctx, scheduledEventSources(ctx.marketData));
     const notifyTriggered = (alert: AlertRule, price: number) => {
       ctx.notify({
         body: `${formatAlertDescription(alert)} triggered at ${price}`,
         type: "success",
+        refId: `price:${alert.id}`,
         desktop: "always",
         persistent: true,
         sound: "Glass",
@@ -147,11 +163,13 @@ export const alertsPlugin: GloomPlugin = {
       async execute(values) {
         const input = parseAlertCommandValues(values);
         if (!input) throw new Error("Use a symbol, condition, and target price.");
+        // 7203:TSE, typed or from a link, is the venue its symbol trades on, as `alerts add` reads it.
+        const symbol = (await settleTypedListingKey(input.symbol, { store: ctx.tickerRepository, dataProvider: ctx.marketData })).toUpperCase();
 
-        const quote = await resolveAlertQuote(ctx.marketData, input.symbol);
+        const quote = await resolveAlertQuote(ctx.marketData, symbol);
 
         const alert = {
-          ...createAlert(quote.symbol || input.symbol, input.condition, input.price),
+          ...createAlert(quote.symbol || symbol, input.condition, input.price),
           ...quoteAlertFields(quote),
         };
         const existing = loadAlerts(ctx);
@@ -169,8 +187,8 @@ export const alertsPlugin: GloomPlugin = {
     ctx.registerCommand({
       id: "set-event-alert",
       label: "Add Event Alert",
-      description: "Create a filing, news, earnings or market alert",
-      keywords: ["alert", "event", "congress", "13f", "fund", "member", "follow"],
+      description: "Create an alert before earnings, CPI or FOMC, or for filings, news and market moves",
+      keywords: ["alert", "event", "congress", "13f", "fund", "member", "follow", "earnings", "cpi", "fomc", "days before"],
       category: "data",
       wizardLayout: "form",
       wizard: [
@@ -191,13 +209,28 @@ export const alertsPlugin: GloomPlugin = {
         })),
         ...researchWizardFields,
       ],
-      execute(values = {}) {
+      async execute(values = {}) {
         const event = values?.event || "congress-watched";
-        const result = readEventAlerts(ctx.configState.get<string>(EVENT_ALERTS_KEY) || "[]");
-        if (result.error) throw new Error(result.error);
-        if (result.rules.length >= MAX_EVENT_ALERTS)
+        const initial = readEventAlerts(ctx.configState.get<string>(EVENT_ALERTS_KEY) || "[]");
+        if (initial.error) throw new Error(initial.error);
+        if (initial.rules.length >= MAX_EVENT_ALERTS)
           throw new Error("Keep at most 40 event alerts.");
-        const rule = isResearchAlertKind(event) ? createResearchAlert(event, values) : createEventAlert(event, values?.[event] || "");
+        // Earnings and macro events alert before a date: one has to be known, or the rule would never go off.
+        const scheduled = event === "earnings_date" || event === "macro_event";
+        if (scheduled && parseLeadDays(values[`${event}:leadDays`]) == null)
+          throw new Error(`Days before must be a whole number from 1 to ${MAX_LEAD_DAYS}.`);
+        let rule = isResearchAlertKind(event) ? createResearchAlert(event, values) : createEventAlert(event, values?.[event] || "");
+        const target = scheduled ? readScheduledRule(rule)?.target : null;
+        if (target) {
+          const lookup = (await lookupScheduledDates([target], scheduledEventSources(ctx.marketData), newYorkToday()))
+            .get(scheduledTargetKey(target));
+          if (!lookup || "error" in lookup) throw new Error(eventDateUnavailableMessage(target, lookup?.error ?? "no answer"));
+          if (!lookup.date) throw new Error(noUpcomingEventMessage(target));
+          rule = { ...rule, eventDate: lookup.date };
+        }
+        // Read again: the lookup took a while and the rules may have changed meanwhile.
+        const result = scheduled ? readEventAlerts(ctx.configState.get<string>(EVENT_ALERTS_KEY) || "[]") : initial;
+        if (result.error) throw new Error(result.error);
         if (
           result.rules.some(
             (existing) =>
@@ -207,8 +240,9 @@ export const alertsPlugin: GloomPlugin = {
           )
         )
           throw new Error("This event is already followed.");
-        ctx.configState.set(EVENT_ALERTS_KEY, JSON.stringify([...result.rules, rule]));
+        await ctx.configState.set(EVENT_ALERTS_KEY, JSON.stringify([...result.rules, rule]));
         ctx.notify({ body: "Event alert saved.", type: "success" });
+        if (scheduled) checkScheduledEventAlertsNow();
       },
     });
 
@@ -321,6 +355,8 @@ export const alertsPlugin: GloomPlugin = {
   dispose() {
     catalystAlertsStop?.();
     catalystAlertsStop = null;
+    scheduledAlertsStop?.();
+    scheduledAlertsStop = null;
     pollGeneration += 1;
     alertStream?.dispose();
     alertStream = null;

package/src/plugins/builtin/alerts/pane.tsx

@@ -3,7 +3,7 @@ import { Button, PaneStatusBody, PaneFooterScope, usePaneTabs } from "../../../c
 import { usePluginPaneState } from "../../runtime";
 import { EventAlertsPane } from "./events-pane";
 import { AlertHistoryPane } from "./history-pane";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import {
   confirmDialog,
   DataTableView,
@@ -42,6 +42,8 @@ import { useQuoteEntries } from "../../../market-data/hooks";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
 import { alertInstrument, streamedAlertQuote, syncAlertQuoteStream } from "./live";
 import { quoteAlertFields } from "./quotes";
+import { clearPriceAlertFocus, getPriceAlertFocus, subscribePriceAlertFocus } from "./focus";
+import { alertTarget, alertViewHints, priceRuleSubject, useOpenAlertTarget } from "./targets";
 
 type AlertColumnId =
   | "status"
@@ -79,6 +81,14 @@ const ALERT_TABS = [
 
 export function AlertsPane(props: PaneProps) {
   const [tab, setTab] = usePluginPaneState<string>("tab", "prices");
+  // A missed price alert opened from the Unread list selects its rule on Prices.
+  useEffect(() => {
+    const showPrices = () => {
+      if (getPriceAlertFocus()) setTab("prices");
+    };
+    showPrices();
+    return subscribePriceAlertFocus(showPrices);
+  }, [setTab]);
   const { strip: tabStrip, rows: tabRows } = usePaneTabs({
     tabs: ALERT_TABS,
     activeValue: tab,
@@ -124,6 +134,15 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
     };
   }, [alertsJson]);
 
+  const focusedAlertId = useSyncExternalStore(subscribePriceAlertFocus, getPriceAlertFocus, getPriceAlertFocus);
+  useEffect(() => {
+    if (!focusedAlertId) return;
+    // A rule deleted since it fired leaves the selection where it was.
+    const index = rows.findIndex((row) => row.id === focusedAlertId);
+    if (index >= 0) setSelectedIdx(index);
+    clearPriceAlertFocus();
+  }, [focusedAlertId, rows]);
+
   // The store keeps the last checked price at a coarse cadence; while a
   // symbol streams the table shows its live price instead.
   const liveInstruments = useMemo(() => {
@@ -181,6 +200,10 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
     if (selected) void deleteAlert(selected.id);
   }, [deleteAlert, rows, selectedIdx]);
 
+  const selectedRule = rows[selectedIdx];
+  const selectedTarget = useMemo(() => selectedRule ? alertTarget(priceRuleSubject(selectedRule)) : null, [selectedRule]);
+  const openTarget = useOpenAlertTarget();
+
   const rearmSelectedAlert = useCallback(() => {
     const selected = rows[selectedIdx];
     if (selected?.status === "triggered") rearmAlert(selected.id);
@@ -227,6 +250,7 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
         : [],
     hints: [
       { id: "add", key: "a", label: "dd alert", onPress: startAddAlert },
+      ...alertViewHints(selectedTarget, openTarget),
       {
         id: "edit",
         key: "e",
@@ -249,6 +273,8 @@ function PriceAlertsPane({ focused, width, height }: PaneProps) {
     deleteSelectedAlert,
     editSelectedAlert,
     rearmSelectedAlert,
+    selectedTarget,
+    openTarget,
     rows,
     selectedIdx,
     quoteError,

package/src/plugins/builtin/alerts/research-builder.ts

@@ -1,9 +1,11 @@
 import type { GloomPlugin } from "../../../types/plugin";
-import { isResearchAlertKind, normalizeResearchRule, readResearchRule, RESEARCH_ALERT_FORMS, type ResearchAlertKind } from "./research-rules";
+import { DEFAULT_LEAD_DAYS, isResearchAlertKind, MACRO_ALERT_EVENTS, normalizeResearchRule, readResearchRule, RESEARCH_ALERT_FORMS, type MacroAlertEvent, type ResearchAlertKind } from "./research-rules";
 import type { EventAlertRule } from "./events";
 
+/** What a macro event is called in a rule, a list and a notification. */
+export const MACRO_EVENT_NAMES: Record<MacroAlertEvent, string> = { cpi: "CPI release", fomc: "FOMC decision" };
 export const RESEARCH_LABELS: Record<ResearchAlertKind, string> = {
-  perps_threshold: "Perpetual threshold", earnings_date: "Earnings date", filing_type: "SEC filing", news_keyword: "News keyword", analyst_change: "Analyst change", fifty_two_week: "52-week range", unusual_volume: "Unusual volume", short_interest_change: "Short interest", insider_trade: "Insider trade", iv_spike: "IV spike", options_flow: "Options flow",
+  perps_threshold: "Perpetual threshold", earnings_date: "Earnings date", macro_event: "Macro event", filing_type: "SEC filing", news_keyword: "News keyword", analyst_change: "Analyst change", fifty_two_week: "52-week range", unusual_volume: "Unusual volume", short_interest_change: "Short interest", insider_trade: "Insider trade", iv_spike: "IV spike", options_flow: "Options flow",
 };
 type Command = Parameters<Parameters<NonNullable<GloomPlugin["setup"]>>[0]["registerCommand"]>[0];
 type Field = NonNullable<Command["wizard"]>[number];
@@ -15,9 +17,11 @@ export const researchWizardFields: Field[] = Object.keys(RESEARCH_LABELS).flatMa
     { key: "direction", label: "Crossing", type: "select", defaultValue: "above", options: choices(["above", "below"]) },
     { key: "threshold", label: "Threshold (%)", type: "number", defaultValue: "0.1" },
   ] : kind === "iv_spike" ? [{key:"contract", label:"OCC contract", type:"text", placeholder:"AAPL261016C00300000", required:true}]
+    : kind === "macro_event" ? [{key:"event", label:"Release", type:"select", defaultValue:"cpi", options:MACRO_ALERT_EVENTS.map((value) => ({value, label:MACRO_EVENT_NAMES[value]}))}]
     : [{key:"symbol",label:kind === "news_keyword" ? "Symbol (optional)" : kind === "options_flow" ? "Symbol (blank: portfolio and watchlists)" : "Symbol",type:"text",placeholder:"AAPL", required:kind !== "news_keyword" && kind !== "options_flow"},
       {key:"exchange",label:"US exchange",type:"select",defaultValue:"US",options:choices(["US","NASDAQ","NYSE","ARCA","AMEX","BATS","OTC"])}];
-  if (kind === "earnings_date") fields.push({key:"leadDays",label:"Days before earnings",type:"number",defaultValue:"1"});
+  if (kind === "earnings_date") fields.push({key:"leadDays",label:"Days before earnings",type:"number",defaultValue:String(DEFAULT_LEAD_DAYS)});
+  if (kind === "macro_event") fields.push({key:"leadDays",label:"Days before",type:"number",defaultValue:String(DEFAULT_LEAD_DAYS)});
   if (kind === "filing_type") fields.push({key:"form",label:"Filing type",type:"select",defaultValue:"8-K",options:choices([...RESEARCH_ALERT_FORMS])});
   if (kind === "news_keyword") fields.push({key:"keyword",label:"Keyword or phrase",type:"text",required:true,placeholder:"buyback"});
   const directions: Partial<Record<ResearchAlertKind, string[]>> = {analyst_change:["any","upgrade","downgrade"],fifty_two_week:["high","low"],short_interest_change:["either","increase","decrease"],insider_trade:["either","buy","sell"],options_flow:["any","calls","puts"]};
@@ -65,6 +69,7 @@ export function researchAlertDescription(rule: EventAlertRule): string {
   switch(rule.kind) {
     case "perps_threshold": return `${config.marketId} · ${config.metric} ${config.direction} ${((config.threshold ?? 0) * 100).toFixed(3)}%`;
     case "earnings_date": return `${symbol} · ${config.leadDays}d before`;
+    case "macro_event": return `${MACRO_EVENT_NAMES[config.event as MacroAlertEvent] ?? config.event} · ${config.leadDays}d before`;
     case "filing_type": return `${symbol} · ${config.form}`;
     case "news_keyword": return `${symbol} · ${config.keyword}`;
     case "analyst_change": case "insider_trade": return `${symbol} · ${config.direction}`;

package/src/plugins/builtin/alerts/research-rules.ts

@@ -1,6 +1,7 @@
 
 const RESEARCH_ALERT_KINDS = [
   "earnings_date",
+  "macro_event",
   "filing_type",
   "news_keyword",
   "analyst_change",
@@ -27,7 +28,17 @@ export interface ResearchAlertConfig {
   marketId?: string
   metric?: "funding8h" | "oiChange24h" | "premium" | "closedMarketPremium"
   print?: string
+  /** Macro event: which scheduled release (`MACRO_ALERT_EVENTS`). */
+  event?: string
 }
+/** Days before a scheduled event (earnings, a macro release) an alert fires when none is given, and the most it takes. */
+export const DEFAULT_LEAD_DAYS = 1
+export const MAX_LEAD_DAYS = 14
+/** Scheduled US releases a macro event rule can follow, by the name the CLI and the form take. */
+export const MACRO_ALERT_EVENTS = ["cpi", "fomc"] as const
+export type MacroAlertEvent = (typeof MACRO_ALERT_EVENTS)[number]
+export const isMacroAlertEvent = (value: unknown): value is MacroAlertEvent =>
+  MACRO_ALERT_EVENTS.includes(value as MacroAlertEvent)
 export const RESEARCH_ALERT_FORMS = [
   "8-K",
   "10-K",
@@ -83,7 +94,11 @@ export function normalizeResearchRule(
     const input: unknown = typeof raw === "string" ? JSON.parse(raw) : raw
     if (!object(input) || input.version !== 1) return null
     const result: ResearchAlertConfig = { version: 1 }
-    if (kind === "perps_threshold") {
+    if (kind === "macro_event") {
+      const event = typeof input.event === "string" ? input.event.trim().toLowerCase() : ""
+      if (!isMacroAlertEvent(event)) return null
+      result.event = event
+    } else if (kind === "perps_threshold") {
       const marketId = typeof input.marketId === "string" ? input.marketId.trim() : "";
       const metric = input.metric;
       if (!/^[a-z][a-z0-9-]*:[^\s:]*:[^\s]+$/.test(marketId) || marketId.length > 180
@@ -148,7 +163,8 @@ export function normalizeResearchRule(
         direction(["above", "below"], "above");
         break;
       case "earnings_date":
-        numeric("leadDays", 1, 0, 14, true)
+      case "macro_event":
+        numeric("leadDays", DEFAULT_LEAD_DAYS, 0, MAX_LEAD_DAYS, true)
         break
       case "filing_type": {
         const form =

package/src/plugins/builtin/alerts/scheduled-check.ts

@@ -0,0 +1,122 @@
+import type { GloomPluginContext } from "../../../types/plugin";
+import { newYorkToday } from "../earnings/board-model";
+import { EVENT_ALERTS_KEY, isScheduledEventRule, readEventAlerts, type EventAlertRule } from "./events";
+import {
+  lookupScheduledDates,
+  readScheduledRule,
+  scheduledAlertMessage,
+  scheduledPhase,
+  scheduledTargetKey,
+  type ScheduledEventSources,
+} from "./scheduled";
+
+/** Event dates move rarely and the sources cache for longer than this. */
+const CHECK_INTERVAL_MS = 15 * 60_000;
+/** The first check waits for the app to settle rather than racing its first paint. */
+const FIRST_CHECK_DELAY_MS = 5_000;
+
+let checkNow: (() => void) | null = null;
+
+/** Check at once, after a rule was added, rather than at the next interval. */
+export function checkScheduledEventAlertsNow(): void {
+  checkNow?.();
+}
+
+/**
+ * Looks up the next date of every active earnings and macro event rule, keeps
+ * it on the rule so lists can show it, and notifies once per event when its
+ * lead time is reached. The date the rule alerted for is saved on it, so a
+ * restart or another device does not alert again; the next event's date arms
+ * it again. Runs while the app is open; with no such rules it requests nothing.
+ */
+export function startScheduledEventAlerts(
+  ctx: Pick<GloomPluginContext, "configState" | "notify" | "showPane" | "log">,
+  sources: ScheduledEventSources,
+  now: () => number = Date.now,
+): () => void {
+  let stopped = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let running = false;
+  let rerun = false;
+  const read = () => readEventAlerts(ctx.configState.get<string>(EVENT_ALERTS_KEY) ?? "[]");
+
+  const check = async () => {
+    const { rules, error } = read();
+    if (error) return;
+    const watched = rules.filter((rule) => rule.status === "active" && isScheduledEventRule(rule));
+    if (watched.length === 0) return;
+    const today = newYorkToday(new Date(now()));
+    const targets = watched.flatMap((rule) => readScheduledRule(rule)?.target ?? []);
+    const dates = await lookupScheduledDates(targets, sources, today);
+    if (stopped) return;
+    for (const [key, lookup] of dates) {
+      if ("error" in lookup) ctx.log.warn("Event dates unavailable", { target: key, error: lookup.error });
+    }
+
+    // Read again: the pane or a sync may have changed the rules while the dates loaded.
+    const current = read();
+    if (current.error) return;
+    let changed = false;
+    const next = current.rules.map((rule): EventAlertRule => {
+      const scheduled = rule.status === "active" ? readScheduledRule(rule) : null;
+      if (!scheduled) return rule;
+      let updated = rule;
+      const lookup = dates.get(scheduledTargetKey(scheduled.target));
+      // A failed lookup keeps the date already known.
+      if (lookup && "date" in lookup && lookup.date !== (rule.eventDate ?? null)) {
+        const { eventDate: _previous, ...rest } = rule;
+        updated = lookup.date ? { ...rest, eventDate: lookup.date } : rest;
+        changed = true;
+      }
+      if (updated.eventDate && scheduledPhase(updated.eventDate, scheduled.leadDays, updated.firedFor, today) === "due") {
+        ctx.notify({
+          body: scheduledAlertMessage(scheduled.target, updated.eventDate, today),
+          type: "info",
+          desktop: "always",
+          persistent: true,
+          action: { label: "Open", onClick: () => ctx.showPane("alerts") },
+        });
+        updated = { ...updated, firedFor: updated.eventDate };
+        changed = true;
+      }
+      return updated;
+    });
+    if (changed && !stopped) await ctx.configState.set(EVENT_ALERTS_KEY, JSON.stringify(next));
+  };
+
+  const run = async () => {
+    if (stopped) return;
+    if (running) {
+      rerun = true;
+      return;
+    }
+    running = true;
+    if (timer) clearTimeout(timer);
+    timer = null;
+    try {
+      await check();
+    } catch (error) {
+      if (!stopped) ctx.log.warn("Event alerts check failed", { error: String(error) });
+    } finally {
+      running = false;
+      if (!stopped) {
+        if (rerun) {
+          rerun = false;
+          void run();
+        } else {
+          timer = setTimeout(() => void run(), CHECK_INTERVAL_MS);
+        }
+      }
+    }
+  };
+
+  timer = setTimeout(() => void run(), FIRST_CHECK_DELAY_MS);
+  const trigger = () => void run();
+  checkNow = trigger;
+  return () => {
+    stopped = true;
+    if (timer) clearTimeout(timer);
+    timer = null;
+    if (checkNow === trigger) checkNow = null;
+  };
+}

package/src/plugins/builtin/alerts/scheduled-sources.ts

@@ -0,0 +1,25 @@
+import type { DataProvider } from "../../../types/data-provider";
+import { loadCpiBoard } from "../cpi/client";
+import { loadEarningsCalendar } from "../earnings/data/cache";
+import { loadRatePath } from "../rate-path/client";
+import type { ScheduledEventSources } from "./scheduled";
+
+/**
+ * The next event dates from the data the app already shows: the earnings
+ * calendar ERN reads, the CPI board's release calendar and the FOMC meetings
+ * WIRP prices, each through its own cache.
+ */
+export function scheduledEventSources(marketData: DataProvider | null | undefined): ScheduledEventSources {
+  return {
+    async earnings(symbols) {
+      if (!marketData?.getEarningsCalendar) throw new Error("Earnings dates are not available.");
+      return (await loadEarningsCalendar(marketData, symbols)).events;
+    },
+    async cpi() {
+      return (await loadCpiBoard()).payload;
+    },
+    async fomc() {
+      return (await loadRatePath()).meetings;
+    },
+  };
+}