gloomberb 0.13.1 → 0.13.2

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

@@ -17,6 +17,7 @@ import { useNewsArticleFooter } from "./wire/news/footer";
 import { usePersistedNewsArticles } from "./wire/persisted-articles";
 import { useNewsReadState } from "./wire/read-state";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
+import { tickerNewsHeadless } from "./headless";
 
 const NEWS_ITEM_LIMIT = 50;
 const DEFAULT_SORT: NewsSortPreference = { columnId: "time", direction: "desc" };
@@ -140,15 +141,18 @@ export const tickerNewsModule: PluginModule = {
   ],
 
   paneTemplates: [
-    createTickerSurfacePaneTemplate({
-      id: "ticker-news-pane",
-      paneId: "ticker-news",
-      label: "Ticker News",
-      description: "Company news for the selected ticker.",
-      keywords: ["company", "ticker", "news", "headlines", "cn"],
-      shortcut: "CN",
-      publicShare: true,
-    }),
+    {
+      ...createTickerSurfacePaneTemplate({
+        id: "ticker-news-pane",
+        paneId: "ticker-news",
+        label: "Ticker News",
+        description: "Company news for the selected ticker.",
+        keywords: ["company", "ticker", "news", "headlines", "cn"],
+        shortcut: "CN",
+        publicShare: true,
+      }),
+      headless: tickerNewsHeadless,
+    },
   ],
 
   setup(ctx) {

package/src/plugins/builtin/news/wire/index.tsx

@@ -23,6 +23,7 @@ import { NewsPresetPane } from "./news/preset-pane";
 import { NEWS_QUERY_PRESETS } from "./news/query-presets";
 import type { NewsColumnId, NewsSortPreference } from "./news/table";
 import { createRssNewsCapability } from "./rss/source";
+import { newsFeedHeadless } from "../headless";
 
 interface NewsPresetPaneConfig {
   paneKey: string;
@@ -107,7 +108,7 @@ export const newsWireModule: PluginModule = {
   ],
   paneTemplates: [
     { id: "news-top-pane", paneId: "news-top", label: "Top News", description: "Curated top market stories ranked by importance", keywords: ["top", "news", "headlines", "stories"], shortcut: { prefix: "TOP" } },
-    { id: "news-feed-pane", paneId: "news-feed", label: "News Feed", description: "Chronological market news firehose", keywords: ["news", "feed", "firehose", "wire", "stream"], shortcut: { prefix: "N" } },
+    { id: "news-feed-pane", paneId: "news-feed", label: "News Feed", description: "Chronological market news firehose", keywords: ["news", "feed", "firehose", "wire", "stream"], shortcut: { prefix: "N" }, headless: newsFeedHeadless },
     { id: "news-industry-pane", paneId: "news-industry", label: "Sector News", description: "Market news filtered by sector", keywords: ["news", "industry", "sector", "ni", "filter"], shortcut: { prefix: "NI" } },
     { id: "news-breaking-pane", paneId: "news-breaking", label: "Breaking News", description: "Breaking and urgent market news", keywords: ["first", "breaking", "urgent", "alert", "flash"], shortcut: { prefix: "FIRST" } },
   ],

package/src/plugins/builtin/research/analyst-headless.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { AnalystResearchData } from "../../../types/financials";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createAnalystResearchHeadless } from "./analyst-headless";
+
+const data: AnalystResearchData = {
+  symbol: "AMD",
+  currency: "USD",
+  priceTarget: { current: 150, average: 180, low: 120, median: 175, high: 230 },
+  recommendationRating: 8.4,
+  recommendations: [{ period: "current month", strongBuy: 10, buy: 8, hold: 4, sell: 1 }],
+  ratings: [
+    { date: "2026-08-20", firm: "Beta", action: "Maintains", current: "Buy", currentPriceTarget: 190 },
+    { date: "2026-08-25", firm: "Alpha", action: "Raises", current: "Buy", prior: "Hold", currentPriceTarget: 210, priorPriceTarget: 180 },
+  ],
+  earningsEstimates: [],
+  revenueEstimates: [],
+};
+
+function context(): HeadlessPaneContext {
+  return {
+    marketData: createTestDataProvider(),
+    apiClient: {} as HeadlessPaneContext["apiClient"],
+    config: createDefaultConfig("/tmp/gloomberb-headless-analyst"),
+    signal: new AbortController().signal,
+  };
+}
+
+function args(overrides: Partial<HeadlessPaneLoadArgs["options"]> = {}): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: "AMD",
+    argument: "AMD",
+    symbols: ["AMD"],
+    options: { sort: "date", order: "desc", limit: 25, ...overrides },
+  };
+}
+
+describe("analyst research headless model", () => {
+  test("projects summary and ratings while applying sort and limit", async () => {
+    const headless = createAnalystResearchHeadless({ loadData: async () => data });
+
+    const latest = await headless.load(args({ limit: 1 }), context());
+    expect(latest.sections[0]?.title).toBe("Summary");
+    const entries = "entries" in latest.sections[0]! ? latest.sections[0]!.entries : [];
+    expect(entries.slice(0, 2)).toMatchObject([
+      { label: "Average target", value: 180 },
+      { label: "Target upside", value: 0.2 },
+    ]);
+    expect(latest.sections[1]).toMatchObject({
+      title: "Recent analyst actions",
+      rows: [{ firm: "Alpha", currentPriceTarget: 210, priorPriceTarget: 180 }],
+    });
+
+    const byFirm = await headless.load(args({ sort: "firm", order: "desc", limit: 2 }), context());
+    const ratings = "rows" in byFirm.sections[1]! ? byFirm.sections[1]!.rows : [];
+    expect(ratings.map((row) => row.firm)).toEqual(["Beta", "Alpha"]);
+  });
+});

package/src/plugins/builtin/research/analyst-headless.ts

@@ -0,0 +1,172 @@
+import type {
+  HeadlessBundleSection,
+  HeadlessPaneColumn,
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneEntry,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import type { AnalystResearchData } from "../../../types/financials";
+import { formatCurrency, formatPercent } from "../../../utils/format";
+import { loadAnalystResearch } from "./client";
+import {
+  formatRatingLabel,
+  formatRatingTarget,
+  latestRecommendation,
+  recommendationTotal,
+  sortRatingRows,
+  targetUpside,
+  type RatingColumnId,
+} from "./analyst-model";
+
+const RATING_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "date", header: "Date" },
+  { key: "firm", header: "Firm" },
+  { key: "action", header: "Action" },
+  { key: "current", header: "Rating" },
+  {
+    key: "target",
+    header: "Target",
+    format: (_value, row) => formatRatingTarget(
+      row as unknown as AnalystResearchData["ratings"][number],
+      String(row.currency ?? "USD"),
+    ).trim(),
+  },
+  { key: "prior", header: "Prior" },
+];
+
+const SORT_COLUMNS: Record<string, RatingColumnId> = {
+  date: "date",
+  firm: "firm",
+  action: "action",
+  rating: "current",
+  target: "target",
+};
+
+function overviewEntries(data: AnalystResearchData): HeadlessPaneEntry[] {
+  const target = data.priceTarget;
+  const currency = target?.currency ?? data.currency ?? "USD";
+  const recommendation = latestRecommendation(data);
+  const upside = targetUpside(target);
+  return [
+    {
+      label: "Average target",
+      value: target?.average ?? null,
+      formatted: target?.average == null ? "-" : formatCurrency(target.average, currency),
+    },
+    {
+      label: "Target upside",
+      value: upside ?? null,
+      formatted: upside == null ? "-" : formatPercent(upside),
+    },
+    {
+      label: "Target range",
+      value: target ? { low: target.low, median: target.median, high: target.high } : null,
+      formatted: target
+        ? [target.low, target.median, target.high]
+          .map((value) => value == null ? "-" : formatCurrency(value, currency))
+          .join(" / ")
+        : "-",
+    },
+    {
+      label: "Recommendation rating",
+      value: data.recommendationRating ?? null,
+      formatted: formatRatingLabel(data.recommendationRating),
+    },
+    { label: "Analysts", value: recommendationTotal(data) },
+    {
+      label: "Recommendation mix",
+      value: recommendation ? {
+        period: recommendation.period,
+        strongBuy: recommendation.strongBuy ?? 0,
+        buy: recommendation.buy ?? 0,
+        hold: recommendation.hold ?? 0,
+        sell: recommendation.sell ?? 0,
+        strongSell: recommendation.strongSell ?? 0,
+      } : null,
+      formatted: recommendation
+        ? `SB ${recommendation.strongBuy ?? 0}  B ${recommendation.buy ?? 0}  H ${recommendation.hold ?? 0}  S ${(recommendation.sell ?? 0) + (recommendation.strongSell ?? 0)}`
+        : "-",
+    },
+  ];
+}
+
+export interface AnalystResearchHeadlessDependencies {
+  loadData(
+    symbol: string,
+    args: HeadlessPaneLoadArgs,
+    ctx: HeadlessPaneContext,
+  ): Promise<AnalystResearchData>;
+}
+
+const defaultDependencies: AnalystResearchHeadlessDependencies = {
+  loadData: (symbol, _args, ctx) => loadAnalystResearch(ctx.marketData, symbol),
+};
+
+export function createAnalystResearchHeadless(
+  dependencies: AnalystResearchHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "Ticker whose analyst research should be loaded.",
+    },
+    options: [
+      {
+        key: "sort",
+        description: "Column used to sort analyst actions.",
+        type: "enum",
+        values: Object.keys(SORT_COLUMNS).map((value) => ({ value })),
+        defaultValue: "date",
+      },
+      {
+        key: "order",
+        description: "Sort direction.",
+        type: "enum",
+        values: [{ value: "desc" }, { value: "asc" }],
+        defaultValue: "desc",
+      },
+      {
+        key: "limit",
+        aliases: ["count", "rows"],
+        description: "Maximum analyst action rows.",
+        type: "integer",
+        defaultValue: 25,
+        minimum: 1,
+        maximum: 100,
+      },
+    ],
+    describe: (args) => `Analyst Research | ${args.symbols[0]}`,
+    async load(args, ctx) {
+      const symbol = args.symbols[0]!;
+      const data = await dependencies.loadData(symbol, args, ctx);
+      const currency = data.priceTarget?.currency ?? data.currency ?? "USD";
+      const ratings = sortRatingRows(data.ratings, {
+        columnId: SORT_COLUMNS[String(args.options.sort)] ?? "date",
+        direction: args.options.order === "asc" ? "asc" : "desc",
+      })
+        .slice(0, Number(args.options.limit))
+        .map((rating) => ({
+          ...rating,
+          target: rating.currentPriceTarget ?? rating.priorPriceTarget ?? null,
+          currency,
+        }));
+      const sections: HeadlessBundleSection[] = [
+        { title: "Summary", entries: overviewEntries(data) },
+        { title: "Recent analyst actions", columns: RATING_COLUMNS, rows: ratings },
+      ];
+      return {
+        sections,
+        metadata: {
+          symbol: data.symbol || symbol,
+          name: data.name ?? null,
+          currency,
+        },
+      };
+    },
+  };
+}
+
+export const analystResearchHeadless = createAnalystResearchHeadless();

package/src/plugins/builtin/research/analyst-model.ts

@@ -0,0 +1,219 @@
+import type { DataTableColumn } from "../../../components";
+import type { AnalystRatingRecord, AnalystResearchData } from "../../../types/financials";
+import { formatCurrency, formatNumber } from "../../../utils/format";
+import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
+
+function compactPeriod(period: string): string {
+  return period
+    .replace("current ", "")
+    .replace("previous ", "prev ")
+    .replace("next_", "next ")
+    .replace(/_/g, " ");
+}
+
+export function targetUpside(target: AnalystResearchData["priceTarget"]): number | undefined {
+  if (!target?.average || !target.current) return undefined;
+  return (target.average - target.current) / target.current;
+}
+
+export function latestRecommendation(data: AnalystResearchData | null) {
+  return data?.recommendations[0] ?? null;
+}
+
+export function recommendationTotal(data: AnalystResearchData | null): number {
+  const rec = latestRecommendation(data);
+  if (!rec) return 0;
+  return (rec.strongBuy ?? 0) + (rec.buy ?? 0) + (rec.hold ?? 0) + (rec.sell ?? 0) + (rec.strongSell ?? 0);
+}
+
+export function formatRatingLabel(value: number | undefined): string {
+  return value == null ? "-" : `${formatNumber(value, 1)}/10`;
+}
+
+export function formatPriceTarget(value: number | undefined, currency: string): string {
+  if (value == null) return "-";
+  return formatCurrency(value, currency)
+    .replace(/\.00\b/, "")
+    .replace(/(\.\d)0\b/, "$1");
+}
+
+const TARGET_SEPARATOR = " → ";
+
+export interface RatingTargetColumnSizing {
+  targetPriorWidth: number;
+  targetCurrentWidth: number;
+}
+
+export function formatRatingTarget(
+  row: AnalystResearchData["ratings"][number],
+  currency: string,
+  sizing?: Partial<RatingTargetColumnSizing>,
+): string {
+  const current = row.currentPriceTarget;
+  const prior = row.priorPriceTarget;
+  if (current == null && prior == null) return "-";
+  if (current == null) return ` ${formatPriceTarget(prior, currency)}`;
+  if (prior == null) return ` ${formatPriceTarget(current, currency)}`;
+
+  const priorText = formatPriceTarget(prior, currency).padStart(sizing?.targetPriorWidth ?? 0);
+  const currentText = formatPriceTarget(current, currency).padEnd(sizing?.targetCurrentWidth ?? 0);
+  return ` ${priorText}${TARGET_SEPARATOR}${currentText}`;
+}
+
+export function ratingTargetDelta(row: AnalystResearchData["ratings"][number]): number | null {
+  if (row.currentPriceTarget == null || row.priorPriceTarget == null) return null;
+  return row.currentPriceTarget - row.priorPriceTarget;
+}
+
+export type RatingColumnId = "date" | "firm" | "action" | "current" | "target" | "prior";
+export type RatingColumn = DataTableColumn & { id: RatingColumnId } & Partial<RatingTargetColumnSizing>;
+
+export interface RatingSortPreference {
+  columnId: RatingColumnId;
+  direction: SortDirection;
+}
+
+export const DEFAULT_RATING_SORT: RatingSortPreference = {
+  columnId: "date",
+  direction: "desc",
+};
+
+const DEFAULT_RATING_SORT_DIRECTIONS: Record<RatingColumnId, SortDirection> = {
+  date: "desc",
+  firm: "asc",
+  action: "asc",
+  current: "asc",
+  target: "desc",
+  prior: "asc",
+};
+
+const BASE_RATING_COLUMNS: RatingColumn[] = [
+  { id: "date", label: "DATE", width: 10, align: "left" },
+  { id: "firm", label: "FIRM", width: 20, align: "left" },
+  { id: "action", label: "ACTION", width: 10, align: "left" },
+  { id: "current", label: "RATING", width: 13, align: "left" },
+  { id: "target", label: "TARGET", width: 13, align: "left" },
+  { id: "prior", label: "PRIOR", width: 13, align: "left" },
+];
+
+export function buildRatingColumns(
+  rows: readonly AnalystRatingRecord[],
+  currency: string,
+): RatingColumn[] {
+  const targetSizing = rows.reduce<RatingTargetColumnSizing>(
+    (sizing, row) => ({
+      targetPriorWidth: Math.max(
+        sizing.targetPriorWidth,
+        row.priorPriceTarget == null ? 0 : formatPriceTarget(row.priorPriceTarget, currency).length,
+      ),
+      targetCurrentWidth: Math.max(
+        sizing.targetCurrentWidth,
+        row.currentPriceTarget == null ? 0 : formatPriceTarget(row.currentPriceTarget, currency).length,
+      ),
+    }),
+    { targetPriorWidth: 0, targetCurrentWidth: 0 },
+  );
+  const targetWidth = rows.reduce(
+    (width, row) => Math.max(width, formatRatingTarget(row, currency, targetSizing).length),
+    BASE_RATING_COLUMNS.find((column) => column.id === "target")?.width ?? 13,
+  );
+
+  return BASE_RATING_COLUMNS.map((column) => {
+    return column.id === "target" ? { ...column, ...targetSizing, width: targetWidth } : column;
+  });
+}
+
+function normalizedText(value: string | undefined): string | null {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed.toLocaleLowerCase() : null;
+}
+
+function ratingTargetSortValue(row: AnalystRatingRecord): number | null {
+  return row.currentPriceTarget ?? row.priorPriceTarget ?? null;
+}
+
+function ratingSortValue(row: AnalystRatingRecord, columnId: RatingColumnId): string | number | null {
+  switch (columnId) {
+    case "date":
+      return normalizedText(row.date);
+    case "firm":
+      return normalizedText(row.firm);
+    case "action":
+      return normalizedText(row.action);
+    case "current":
+      return normalizedText(row.current);
+    case "target":
+      return ratingTargetSortValue(row);
+    case "prior":
+      return normalizedText(row.prior);
+  }
+}
+
+export function sortRatingRows<T extends AnalystRatingRecord>(
+  rows: readonly T[],
+  preference: RatingSortPreference,
+): T[] {
+  return rows
+    .map((row, index) => ({ row, index }))
+    .sort((left, right) => {
+      const primary = compareSortValues(
+        ratingSortValue(left.row, preference.columnId),
+        ratingSortValue(right.row, preference.columnId),
+        preference.direction,
+      );
+      if (primary !== 0) return primary;
+
+      const dateTieBreak = preference.columnId === "date"
+        ? 0
+        : compareSortValues(
+          ratingSortValue(left.row, "date"),
+          ratingSortValue(right.row, "date"),
+          "desc",
+        );
+      if (dateTieBreak !== 0) return dateTieBreak;
+
+      return left.index - right.index;
+    })
+    .map((entry) => entry.row);
+}
+
+export function nextRatingSortPreference(
+  current: RatingSortPreference,
+  columnId: string,
+): RatingSortPreference {
+  const typedColumnId = columnId as RatingColumnId;
+  if (current.columnId !== typedColumnId) {
+    return {
+      columnId: typedColumnId,
+      direction: DEFAULT_RATING_SORT_DIRECTIONS[typedColumnId] ?? "asc",
+    };
+  }
+  return {
+    columnId: typedColumnId,
+    direction: current.direction === "asc" ? "desc" : "asc",
+  };
+}
+
+export function buildAnalystSummaryLines(data: AnalystResearchData | null): string[] {
+  if (!data) return [];
+
+  const target = data.priceTarget;
+  const currency = target?.currency ?? data.currency ?? "USD";
+  const price = (value: number | undefined) => value != null ? formatCurrency(value, currency) : "-";
+  const rec = latestRecommendation(data);
+  const total = recommendationTotal(data);
+  const lines: string[] = [];
+
+  if (target) {
+    lines.push(`low ${price(target.low)}   med ${price(target.median)}   high ${price(target.high)}`);
+  }
+  if (data.recommendationRating != null || rec || total > 0) {
+    lines.push([
+      data.recommendationRating != null ? `rating ${formatRatingLabel(data.recommendationRating)}` : null,
+      rec ? `SB ${rec.strongBuy ?? 0}  B ${rec.buy ?? 0}  H ${rec.hold ?? 0}  S ${(rec.sell ?? 0) + (rec.strongSell ?? 0)}` : null,
+      total > 0 ? `${total} analysts${rec?.period ? ` (${compactPeriod(rec.period)})` : ""}` : null,
+    ].filter(Boolean).join("   "));
+  }
+
+  return lines;
+}