gloomberb 0.12.0 → 0.13.2

package/src/plugins/builtin/news/headless.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test } from "bun:test";
+import type { CloudNewsPayload } from "../../../api-client";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import type { NewsQuery } from "../../../news/types";
+import {
+  createNewsFeedHeadless,
+  createTickerNewsHeadless,
+  type NewsHeadlessDependencies,
+} from "./headless";
+
+function story(
+  id: string,
+  sentiment: CloudNewsPayload["sentiment"],
+  importance: number,
+  publishedAt: string,
+): CloudNewsPayload {
+  return {
+    id,
+    headline: `${id} headline`,
+    summary: `${id} summary`,
+    category: "markets",
+    sentiment,
+    sectors: ["technology"],
+    firstPublishedAt: publishedAt,
+    lastPublishedAt: publishedAt,
+    firstSeenAt: publishedAt,
+    lastSeenAt: publishedAt,
+    primaryUrl: `https://example.com/${id}`,
+    primarySource: "Example Wire",
+    scores: {
+      importance,
+      urgency: importance - 1,
+      marketImpact: importance - 2,
+      novelty: 7,
+      confidence: 90,
+    },
+    flags: { breaking: importance > 80 },
+    variantCount: 1,
+    sourceCount: 1,
+    sources: ["Example Wire"],
+    entities: [],
+    tickerLinks: [{
+      symbol: "AMD",
+      exchange: "NASDAQ",
+      canonicalTicker: "AMD",
+      relationType: "issuer",
+      displayTier: "primary",
+      confidence: 1,
+      relevanceScore: 1,
+    }],
+  };
+}
+
+const stories = [
+  story("newer", "positive", 95, "2026-09-04T20:00:00.000Z"),
+  story("older", "negative", 70, "2026-09-04T18:00:00.000Z"),
+];
+
+function args(
+  symbol: string | null,
+  options: Record<string, string | number | boolean>,
+): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: symbol ?? "",
+    argument: symbol,
+    symbols: symbol ? [symbol] : [],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+function dependencies(seen: NewsQuery[]): NewsHeadlessDependencies {
+  return {
+    loadNews: async (query) => {
+      seen.push(query);
+      return { items: stories, nextCursor: "page-2" };
+    },
+    now: () => new Date("2026-09-04T21:00:00.000Z"),
+  };
+}
+
+describe("news feed headless", () => {
+  test("maps cloud stories into a point-in-time snapshot", async () => {
+    const seen: NewsQuery[] = [];
+    const definition = createNewsFeedHeadless(dependencies(seen));
+
+    const result = await definition.load(
+      args(null, { sentiment: "any", minImportance: 0, limit: 50 }),
+      context,
+    );
+
+    expect(result.asOf).toBe("2026-09-04T21:00:00.000Z");
+    expect(result.items[0]).toMatchObject({
+      id: "newer",
+      headline: "newer headline",
+      tickers: ["AMD"],
+      sentiment: "positive",
+      importance: 95,
+      breaking: true,
+      sourceCount: 1,
+    });
+    expect(seen[0]).toMatchObject({ feed: "latest", limit: 50 });
+  });
+
+  test("applies sentiment and importance options", async () => {
+    const definition = createNewsFeedHeadless(dependencies([]));
+
+    const result = await definition.load(
+      args(null, { sentiment: "positive", minImportance: 90, limit: 50 }),
+      context,
+    );
+
+    expect(result.items.map((item) => item.id)).toEqual(["newer"]);
+  });
+});
+
+describe("ticker news headless", () => {
+  test("requests the ticker feed and applies the row limit", async () => {
+    const seen: NewsQuery[] = [];
+    const definition = createTickerNewsHeadless(dependencies(seen));
+
+    const result = await definition.load(
+      args("AMD:XNAS", { sentiment: "any", minImportance: 0, limit: 1 }),
+      context,
+    );
+
+    expect(seen[0]).toMatchObject({
+      feed: "ticker",
+      ticker: "AMD",
+      exchange: "NASDAQ",
+      tickerTier: "primary",
+      limit: 1,
+    });
+    expect(result.items).toHaveLength(1);
+    expect(result.metadata).toMatchObject({ truncated: true });
+  });
+});

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

@@ -0,0 +1,190 @@
+import type { CloudNewsListResponse } from "../../../api-client";
+import type {
+  HeadlessPaneContext,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessSnapshotResult,
+} from "../../../types/plugin";
+import type { NewsArticle, NewsQuery } from "../../../news/types";
+import {
+  cloudNewsParams,
+  mapCloudNewsArticle,
+} from "../../../sources/gloomberb-cloud/news";
+import { parsePublicTickerKey } from "../../../utils/exchanges";
+
+const NEWS_COLUMNS = [
+  { key: "publishedAt", header: "Published" },
+  { key: "source", header: "Source" },
+  { key: "headline", header: "Headline" },
+  { key: "tickers", header: "Tickers" },
+  { key: "sentiment", header: "Sentiment" },
+  { key: "importance", header: "Score", align: "right" as const },
+];
+
+export interface NewsHeadlessDependencies {
+  loadNews(
+    query: NewsQuery,
+    context: HeadlessPaneContext,
+  ): Promise<CloudNewsListResponse>;
+  now(): Date;
+}
+
+const defaultDependencies: NewsHeadlessDependencies = {
+  loadNews: (query, context) => context.apiClient.getCloudNews(cloudNewsParams(query)),
+  now: () => new Date(),
+};
+
+function newsRow(article: NewsArticle) {
+  return {
+    id: article.id,
+    publishedAt: article.publishedAt.toISOString(),
+    source: article.source,
+    headline: article.title,
+    summary: article.summary ?? null,
+    topic: article.topic,
+    topics: article.topics,
+    sectors: article.sectors,
+    categories: article.categories,
+    tickers: article.tickers,
+    sentiment: article.sentiment ?? null,
+    importance: article.scores.importance,
+    urgency: article.scores.urgency,
+    marketImpact: article.scores.marketImpact,
+    novelty: article.scores.novelty,
+    confidence: article.scores.confidence,
+    breaking: article.isBreaking,
+    developing: article.isDeveloping,
+    sourceCount: article.sourceCount ?? article.items?.length ?? 0,
+    url: article.url,
+  };
+}
+
+function selectedSentiment(args: HeadlessPaneLoadArgs): string {
+  return String(args.options.sentiment ?? "any");
+}
+
+export function projectNewsHeadless(
+  response: CloudNewsListResponse,
+  args: HeadlessPaneLoadArgs,
+  now: Date,
+): HeadlessSnapshotResult {
+  const sentiment = selectedSentiment(args);
+  const minImportance = Number(args.options.minImportance ?? 0);
+  const limit = Number(args.options.limit ?? 50);
+  const matching = response.items
+    .map((item) => mapCloudNewsArticle(item, args.symbols[0]))
+    .filter((article) => sentiment === "any" || article.sentiment === sentiment)
+    .filter((article) => article.importance >= minImportance)
+    .sort((left, right) => right.publishedAt.getTime() - left.publishedAt.getTime());
+  const items = matching.slice(0, limit).map(newsRow);
+
+  return {
+    asOf: now.toISOString(),
+    items,
+    metadata: {
+      nextCursor: response.nextCursor,
+      sentiment,
+      minImportance,
+      total: matching.length,
+      returned: items.length,
+      truncated: items.length < matching.length || response.nextCursor != null,
+    },
+  };
+}
+
+function newsOptions() {
+  return [
+    {
+      key: "sentiment",
+      description: "Story sentiment to include.",
+      type: "enum" as const,
+      values: [
+        { value: "any" },
+        { value: "positive" },
+        { value: "neutral" },
+        { value: "negative" },
+      ],
+      defaultValue: "any",
+    },
+    {
+      key: "minImportance",
+      aliases: ["importance"],
+      description: "Minimum importance score.",
+      type: "integer" as const,
+      defaultValue: 0,
+      minimum: 0,
+      maximum: 100,
+    },
+    {
+      key: "limit",
+      description: "Maximum stories to return.",
+      type: "integer" as const,
+      defaultValue: 50,
+      minimum: 1,
+      maximum: 200,
+    },
+  ];
+}
+
+function queryFor(args: HeadlessPaneLoadArgs, feed: "latest" | "ticker"): NewsQuery {
+  const sentiment = selectedSentiment(args);
+  const ticker = args.symbols[0] ? parsePublicTickerKey(args.symbols[0]) : null;
+  return {
+    feed,
+    ...(feed === "ticker"
+      ? {
+          ticker: ticker?.symbol,
+          exchange: ticker?.exchange,
+          tickerTier: "primary" as const,
+        }
+      : {}),
+    ...(sentiment === "any" ? {} : { sentiment: sentiment as "positive" | "neutral" | "negative" }),
+    minImportance: Number(args.options.minImportance ?? 0),
+    limit: Number(args.options.limit ?? 50),
+  };
+}
+
+export function createNewsFeedHeadless(
+  dependencies: NewsHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"snapshot"> {
+  return {
+    shape: "snapshot",
+    argument: { kind: "none" },
+    options: newsOptions(),
+    columns: NEWS_COLUMNS,
+    describe: "News Feed",
+    async load(args, context) {
+      return projectNewsHeadless(
+        await dependencies.loadNews(queryFor(args, "latest"), context),
+        args,
+        dependencies.now(),
+      );
+    },
+  };
+}
+
+export function createTickerNewsHeadless(
+  dependencies: NewsHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"snapshot"> {
+  return {
+    shape: "snapshot",
+    argument: {
+      kind: "ticker",
+      placeholder: "ticker",
+      description: "Company symbol, optionally qualified as SYMBOL:EXCHANGE.",
+    },
+    options: newsOptions(),
+    columns: NEWS_COLUMNS,
+    describe: (args) => `Ticker News | ${String(args.argument)}`,
+    async load(args, context) {
+      return projectNewsHeadless(
+        await dependencies.loadNews(queryFor(args, "ticker"), context),
+        args,
+        dependencies.now(),
+      );
+    },
+  };
+}
+
+export const newsFeedHeadless = createNewsFeedHeadless();
+export const tickerNewsHeadless = createTickerNewsHeadless();

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();