gloomberb 0.13.1 → 0.13.3

package/src/plugins/builtin/earnings/headless.ts

@@ -0,0 +1,162 @@
+import type { EarningsEvent } from "../../../types/data-provider";
+import type {
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessRowsResult,
+} from "../../../types/plugin";
+import {
+  loadEarningsCalendar,
+  type EarningsCalendarResult,
+} from "./data/cache";
+
+const EARNINGS_COLUMNS = [
+  { key: "date", header: "Date" },
+  { key: "timing", header: "When" },
+  { key: "dateStatus", header: "Status" },
+  { key: "symbol", header: "Ticker" },
+  { key: "name", header: "Name" },
+  { key: "epsEstimate", header: "EPS est", align: "right" as const },
+  { key: "epsLow", header: "EPS low", align: "right" as const },
+  { key: "epsHigh", header: "EPS high", align: "right" as const },
+  { key: "epsGrowth", header: "EPS growth", align: "right" as const },
+  { key: "epsTrend30dAgo", header: "EPS 30D ago", align: "right" as const },
+  { key: "epsRevisionUp30d", header: "Rev up", align: "right" as const },
+  { key: "epsRevisionDown30d", header: "Rev down", align: "right" as const },
+  { key: "revenueEstimate", header: "Sales est", align: "right" as const },
+  { key: "revenueLow", header: "Sales low", align: "right" as const },
+  { key: "revenueHigh", header: "Sales high", align: "right" as const },
+  { key: "revenueGrowth", header: "Sales growth", align: "right" as const },
+  { key: "epsAnalysts", header: "EPS analysts", align: "right" as const },
+  { key: "revenueAnalysts", header: "Sales analysts", align: "right" as const },
+];
+
+export interface EarningsCalendarHeadlessDependencies {
+  loadCalendar(
+    symbols: string[],
+    context: HeadlessPaneContext,
+  ): Promise<EarningsCalendarResult>;
+}
+
+const defaultDependencies: EarningsCalendarHeadlessDependencies = {
+  loadCalendar: (symbols, context) => loadEarningsCalendar(context.marketData, symbols),
+};
+
+function timingMatches(event: EarningsEvent, timing: string): boolean {
+  if (timing === "all") return true;
+  if (timing === "unknown") return !event.timing;
+  return event.timing?.toUpperCase() === timing;
+}
+
+function eventRow(event: EarningsEvent) {
+  return {
+    date: event.earningsDate.toISOString(),
+    earningsCallDate: event.earningsCallDate?.toISOString() ?? null,
+    timing: event.timing || null,
+    dateStatus: event.isDateEstimate == null
+      ? null
+      : event.isDateEstimate
+        ? "estimated"
+        : "confirmed",
+    symbol: event.symbol,
+    name: event.name,
+    epsEstimate: event.epsEstimate ?? null,
+    epsLow: event.epsLow ?? null,
+    epsHigh: event.epsHigh ?? null,
+    epsYearAgo: event.epsYearAgo ?? null,
+    epsGrowth: event.epsGrowth ?? null,
+    epsAnalysts: event.epsAnalysts ?? null,
+    epsTrend7dAgo: event.epsTrend7dAgo ?? null,
+    epsTrend30dAgo: event.epsTrend30dAgo ?? null,
+    epsRevisionUp7d: event.epsRevisionUp7d ?? null,
+    epsRevisionUp30d: event.epsRevisionUp30d ?? null,
+    epsRevisionDown7d: event.epsRevisionDown7d ?? null,
+    epsRevisionDown30d: event.epsRevisionDown30d ?? null,
+    epsActual: event.epsActual ?? null,
+    revenueEstimate: event.revenueEstimate ?? null,
+    revenueLow: event.revenueLow ?? null,
+    revenueHigh: event.revenueHigh ?? null,
+    revenueYearAgo: event.revenueYearAgo ?? null,
+    revenueGrowth: event.revenueGrowth ?? null,
+    revenueAnalysts: event.revenueAnalysts ?? null,
+    revenueActual: event.revenueActual ?? null,
+    surprise: event.surprise ?? null,
+  };
+}
+
+export function projectEarningsCalendarHeadless(
+  result: EarningsCalendarResult,
+  args: HeadlessPaneLoadArgs,
+): HeadlessRowsResult {
+  const timing = String(args.options.timing ?? "all").toUpperCase();
+  const normalizedTiming = timing === "ALL" || timing === "UNKNOWN"
+    ? timing.toLowerCase()
+    : timing;
+  const limit = Number(args.options.limit ?? 50);
+  const matching = result.events
+    .filter((event) => timingMatches(event, normalizedTiming))
+    .sort((left, right) => left.earningsDate.getTime() - right.earningsDate.getTime());
+  const rows = matching.slice(0, limit).map(eventRow);
+
+  return {
+    columns: EARNINGS_COLUMNS,
+    rows,
+    errors: result.refreshError ? [result.refreshError] : undefined,
+    metadata: {
+      fetchedAt: result.fetchedAt,
+      stale: result.stale,
+      timing: normalizedTiming,
+      total: matching.length,
+      returned: rows.length,
+      truncated: rows.length < matching.length,
+    },
+  };
+}
+
+export function createEarningsCalendarHeadless(
+  dependencies: EarningsCalendarHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "symbol-list",
+      placeholder: "tickers",
+      description: "Comma-separated company symbols.",
+      minimum: 1,
+      maximum: 100,
+    },
+    options: [
+      {
+        key: "timing",
+        description: "Release timing to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "BMO" },
+          { value: "AMC" },
+          { value: "TNS" },
+          { value: "unknown" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "limit",
+        description: "Maximum earnings rows to return.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    columns: EARNINGS_COLUMNS,
+    describe: (args) => `Earnings Calendar | ${args.symbols.join(", ")}`,
+    async load(args, context) {
+      return projectEarningsCalendarHeadless(
+        await dependencies.loadCalendar(args.symbols, context),
+        args,
+      );
+    },
+  };
+}
+
+export const earningsCalendarHeadless = createEarningsCalendarHeadless();

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

@@ -7,8 +7,11 @@ import { useAppSelector, usePaneInstance } from "../../../state/app/context";
 import { parseTickerListInput, formatTickerListInput } from "../../../tickers/list";
 import { useAssetData, usePluginPaneState, usePluginTickerActions } from "../../runtime";
 import { useAutoRefresh } from "../shared/auto-refresh";
-import type { PaneSettingsContext, PaneSettingsDef } from "../../../types/plugin";
-import { formatTickerListInput as formatTickers } from "../../../tickers/list";
+import type {
+  PaneSettingsContext,
+  PaneSettingsDef,
+  PaneTemplateCreateOptions,
+} from "../../../types/plugin";
 import {
   attachEarningsCalendarPersistence,
   loadEarningsCalendar,
@@ -23,6 +26,7 @@ import {
   type EarningsDisplayRow,
   type EarningsEventDisplayRow,
 } from "./model";
+import { earningsCalendarHeadless } from "./headless";
 import {
   buildEarningsColumns,
   renderEarningsCell,
@@ -187,6 +191,18 @@ function EarningsCalendarPane({ focused, width, height }: PaneProps) {
   );
 }
 
+/** Tickers named on the command bar or the CLI win over the active collection. */
+function earningsScopeSymbols(options: PaneTemplateCreateOptions | undefined): string[] {
+  if (options?.symbols && options.symbols.length > 0) return options.symbols;
+  const raw = options?.arg?.trim() ?? "";
+  if (!raw) return [];
+  try {
+    return parseTickerListInput(raw);
+  } catch {
+    return [];
+  }
+}
+
 /** The monitor's scope lives in pane settings, so it has to be editable there too. */
 function earningsSettings(context: PaneSettingsContext): PaneSettingsDef {
   const collections = [
@@ -196,7 +212,7 @@ function earningsSettings(context: PaneSettingsContext): PaneSettingsDef {
   const symbols = scopedSymbolsFromSettings(context.settings);
   return {
     title: "Earnings Scope",
-    values: { symbolsText: symbols.length > 0 ? formatTickers(symbols) : "" },
+    values: { symbolsText: symbols.length > 0 ? formatTickerListInput(symbols) : "" },
     fields: [
       {
         key: "symbolsText",
@@ -265,12 +281,22 @@ export const earningsModule: PluginModule = {
       label: "Earnings Calendar",
       description: "Upcoming earnings dates and estimates for your tickers.",
       keywords: ["earn", "earnings", "calendar", "eps", "revenue", "quarterly"],
-      shortcut: { prefix: "ERN" },
-      createInstance: (context) => ({
-        settings: context.activeCollectionId
-          ? { collectionId: context.activeCollectionId }
-          : undefined,
-      }),
+      shortcut: { prefix: "ERN", argPlaceholder: "tickers", argKind: "ticker-list" },
+      headless: earningsCalendarHeadless,
+      // The shortcut takes tickers, so honor them the way the report does.
+      // Ignoring them left `ERN NKE` scoped to the active collection, which
+      // rendered "No tickers in scope" while the report listed NKE's earnings.
+      createInstance: (context, options) => {
+        const symbols = earningsScopeSymbols(options);
+        return {
+          title: symbols.length > 0 ? `ERN ${formatTickerListInput(symbols)}` : undefined,
+          settings: symbols.length > 0
+            ? { symbols, symbolsText: formatTickerListInput(symbols) }
+            : context.activeCollectionId
+              ? { collectionId: context.activeCollectionId }
+              : undefined,
+        };
+      },
     },
     {
       id: "earnings-monitor-pane",

package/src/plugins/builtin/earnings/model.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, test } from "bun:test";
 import type { TickerRecord } from "../../../types/ticker";
-import { groupEarningsByRelativeDate, resolveEarningsCollectionId, trackedEarningsSymbols } from "./model";
+import type { PaneTemplateContext } from "../../../types/plugin";
+import { earningsModule } from "./index";
+import {
+  groupEarningsByRelativeDate,
+  resolveEarningsCollectionId,
+  scopedSymbolsFromSettings,
+  trackedEarningsSymbols,
+} from "./model";
 
 function ticker(
   symbol: string,
@@ -22,6 +29,27 @@ function ticker(
   };
 }
 
+describe("ERN pane scope", () => {
+  /**
+   * The shortcut takes tickers, but the template used to drop them and follow
+   * the active collection instead, so `ERN NKE` opened a pane that reported no
+   * tickers in scope while the same argument produced a report.
+   */
+  test("scopes the pane to the tickers the shortcut was given", async () => {
+    const template = earningsModule.paneTemplates?.find(
+      (candidate) => candidate.id === "earnings-calendar-pane",
+    );
+    const context = { activeCollectionId: "main" } as unknown as PaneTemplateContext;
+
+    const scoped = await template?.createInstance?.(context, { arg: "nke, msft" });
+    expect(scopedSymbolsFromSettings(scoped?.settings)).toEqual(["NKE", "MSFT"]);
+
+    const unscoped = await template?.createInstance?.(context, undefined);
+    expect(scopedSymbolsFromSettings(unscoped?.settings)).toEqual([]);
+    expect(unscoped?.settings?.collectionId).toBe("main");
+  });
+});
+
 describe("trackedEarningsSymbols", () => {
   test("gives settings-less legacy panes one stable collection scope", () => {
     expect(resolveEarningsCollectionId(undefined, "main")).toBe("main");

package/src/plugins/builtin/earnings-calls/data.ts

@@ -4,7 +4,12 @@ import {
   type CloudEarningsTranscriptPayload,
 } from "../../../api-client";
 import { ApiRequestError } from "../../../api-client/errors";
-import type { PluginPersistence } from "../../../types/plugin";
+import type { HeadlessPaneApiClient, PluginPersistence } from "../../../types/plugin";
+
+type EarningsCallsApiClient = Pick<
+  HeadlessPaneApiClient,
+  "getCloudEarningsCalls" | "getCloudEarningsTranscript"
+>;
 
 const LIST_KIND = "calls";
 const TRANSCRIPT_KIND = "transcript";
@@ -83,7 +88,8 @@ function listKey(ticker: string | null): string {
   return ticker ? ticker.toUpperCase() : "__all__";
 }
 
-export async function loadEarningsCalls(
+export async function loadEarningsCallsWithClient(
+  client: EarningsCallsApiClient,
   ticker: string | null,
   options?: { force?: boolean; limit?: number },
 ): Promise<EarningsCallsResult> {
@@ -101,7 +107,7 @@ export async function loadEarningsCalls(
   const active = activeListFetches.get(key);
   if (active && !force) return active;
 
-  const request = apiClient
+  const request = client
     .getCloudEarningsCalls({
       ticker: ticker ?? undefined,
       limit: options?.limit ?? 50,
@@ -155,6 +161,13 @@ export async function loadEarningsCalls(
   return request;
 }
 
+export function loadEarningsCalls(
+  ticker: string | null,
+  options?: { force?: boolean; limit?: number },
+): Promise<EarningsCallsResult> {
+  return loadEarningsCallsWithClient(apiClient, ticker, options);
+}
+
 /**
  * The server answers 202 with a pending marker when a call is known but not
  * transcribed yet, having just queued it. That is not a transcript and must
@@ -163,12 +176,13 @@ export async function loadEarningsCalls(
 export function isPendingTranscript(
   value: CloudEarningsTranscriptPayload | { status?: string } | null,
 ): boolean {
-  if (!value) return false
-  const record = value as { status?: string; turns?: unknown }
-  return record.status === "pending" || !Array.isArray(record.turns)
+  if (!value) return false;
+  const record = value as { status?: string; turns?: unknown };
+  return record.status === "pending" || !Array.isArray(record.turns);
 }
 
-export async function loadTranscript(
+export async function loadTranscriptWithClient(
+  client: EarningsCallsApiClient,
   callId: string,
   options?: { force?: boolean },
 ): Promise<CloudEarningsTranscriptPayload> {
@@ -184,7 +198,7 @@ export async function loadTranscript(
   const active = activeTranscriptFetches.get(callId);
   if (active && !force) return active;
 
-  const request = apiClient
+  const request = client
     .getCloudEarningsTranscript(callId)
     .then((transcript) => {
       if (isPendingTranscript(transcript)) return transcript;
@@ -221,3 +235,10 @@ export async function loadTranscript(
   activeTranscriptFetches.set(callId, request);
   return request;
 }
+
+export function loadTranscript(
+  callId: string,
+  options?: { force?: boolean },
+): Promise<CloudEarningsTranscriptPayload> {
+  return loadTranscriptWithClient(apiClient, callId, options);
+}

package/src/plugins/builtin/earnings-calls/headless.test.ts

@@ -0,0 +1,192 @@
+import { describe, expect, test } from "bun:test";
+import type {
+  CloudEarningsCallPayload,
+  CloudEarningsTranscriptPayload,
+} from "../../../api-client";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import {
+  createEarningsCallsHeadless,
+  createEarningsTranscriptHeadless,
+  type EarningsCallsHeadlessDependencies,
+} from "./headless";
+
+const calls: CloudEarningsCallPayload[] = [
+  {
+    id: "amd-fq2-2026",
+    ticker: "AMD",
+    companyName: "Advanced Micro Devices",
+    fiscalYear: 2026,
+    fiscalQuarter: 2,
+    callAt: "2026-07-29T21:00:00.000Z",
+    status: "published",
+    durationSeconds: 3_600,
+    wordCount: 12_000,
+    hasTranscript: true,
+    sentiment: 0.2,
+  },
+  {
+    id: "amd-fq1-2026",
+    ticker: "AMD",
+    companyName: "Advanced Micro Devices",
+    fiscalYear: 2026,
+    fiscalQuarter: 1,
+    callAt: "2026-04-29T21:00:00.000Z",
+    status: "discovered",
+    durationSeconds: null,
+    wordCount: null,
+    hasTranscript: false,
+    sentiment: null,
+  },
+];
+
+const transcript: CloudEarningsTranscriptPayload = {
+  id: "amd-fq2-2026",
+  ticker: "AMD",
+  companyName: "Advanced Micro Devices",
+  fiscalYear: 2026,
+  fiscalQuarter: 2,
+  callAt: "2026-07-29T21:00:00.000Z",
+  timing: "AMC",
+  webcastUrl: "https://example.com/call",
+  durationSeconds: 3_600,
+  status: "published",
+  fullText: "",
+  turns: [
+    {
+      speaker: "Jean Hu",
+      role: "Chief Financial Officer",
+      company: "AMD",
+      text: `Gross margin expanded. ${"Margin discipline remained strong. ".repeat(80)}`,
+      isQa: false,
+      startSeconds: 120,
+    },
+    {
+      speaker: "Analyst One",
+      role: "Analyst",
+      company: "Research Firm",
+      text: "What should investors expect from the CFO on data center margins?",
+      isQa: true,
+      startSeconds: 2_400,
+    },
+  ],
+  participants: [
+    { name: "Jean Hu", role: "Chief Financial Officer", company: "AMD" },
+  ],
+  summary: "Revenue grew while gross margin expanded.",
+  guidance: "Management expects sequential growth.",
+  riskFactors: "Supply remains constrained.",
+  analystFocus: "Analysts focused on data center margins.",
+  notable: "Management raised its annual outlook.",
+  sentiment: 0.2,
+  sentimentRationale: "Constructive outlook.",
+  qaStartTurn: 1,
+  wordCount: 12_000,
+  asrModel: "test",
+  updatedAt: "2026-07-30T00:00:00.000Z",
+};
+
+function callArgs(options: Record<string, string | number | boolean>): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "",
+    argument: null,
+    symbols: [],
+    options,
+  };
+}
+
+function transcriptArgs(options: Record<string, string | number | boolean>): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AMD",
+    argument: "AMD",
+    symbols: ["AMD"],
+    options,
+  };
+}
+
+function dependencies(): EarningsCallsHeadlessDependencies {
+  return {
+    loadCalls: async () => ({
+      calls,
+      fetchedAt: 123,
+      stale: false,
+    }),
+    loadTranscript: async () => transcript,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+describe("earnings calls headless", () => {
+  test("maps call shelf rows and applies availability", async () => {
+    const definition = createEarningsCallsHeadless(dependencies());
+
+    const result = await definition.load(
+      callArgs({ availability: "pending", limit: 1 }),
+      context,
+    );
+
+    expect(result.rows).toEqual([
+      expect.objectContaining({
+        id: "amd-fq1-2026",
+        ticker: "AMD",
+        status: "queued",
+        hasTranscript: false,
+      }),
+    ]);
+    expect(result.metadata).toMatchObject({ availability: "pending", returned: 1 });
+  });
+});
+
+describe("earnings transcript headless", () => {
+  test("selects a quarter and filters speakers by role acronym", async () => {
+    const definition = createEarningsTranscriptHeadless(dependencies());
+
+    const result = await definition.load(transcriptArgs({
+      section: "transcript",
+      quarter: "FQ2-2026",
+      speaker: "CFO",
+      search: "margin",
+      offset: 0,
+      limit: 20,
+    }), context);
+
+    expect(result.rows.length).toBeGreaterThan(0);
+    expect(result.rows.every((row) => row.speaker === "Jean Hu")).toBe(true);
+    expect(result.metadata).toMatchObject({
+      fiscalYear: 2026,
+      fiscalQuarter: 2,
+      section: "transcript",
+      speaker: "CFO",
+    });
+  });
+
+  test("pages bounded transcript segments and reports truncation", async () => {
+    const definition = createEarningsTranscriptHeadless(dependencies());
+    const first = await definition.load(transcriptArgs({
+      section: "transcript",
+      quarter: "latest",
+      speaker: "CFO",
+      search: "",
+      offset: 0,
+      limit: 1,
+    }), context);
+    const second = await definition.load(transcriptArgs({
+      section: "transcript",
+      quarter: "latest",
+      speaker: "CFO",
+      search: "",
+      offset: 1,
+      limit: 1,
+    }), context);
+
+    expect(first.rows).toHaveLength(1);
+    expect(first.metadata).toMatchObject({
+      returnedSegments: 1,
+      truncated: true,
+      hasMore: true,
+      nextOffset: 1,
+    });
+    expect(second.rows).toHaveLength(1);
+    expect(second.rows[0]?.index).toBe(1);
+  });
+});