gloomberb 0.13.1 → 0.13.2

package/src/plugins/builtin/insider/model.ts

@@ -0,0 +1,72 @@
+import type { SecFilingItem } from "../../../types/data-provider";
+import { formatCompact, formatCurrency } from "../../../utils/format";
+import {
+  transactionTypeLabel,
+  type InsiderTransaction,
+} from "./insider-data";
+
+const NINETY_DAYS_MS = 90 * 24 * 60 * 60 * 1000;
+
+export interface ParsedInsiderFiling {
+  filing: SecFilingItem;
+  transaction: InsiderTransaction | null;
+  isLoading: boolean;
+}
+
+/** Null while filings are still parsing, so the pane never claims no activity early. */
+export function buildInsiderSummary(
+  parsed: ParsedInsiderFiling[],
+  now = Date.now(),
+): string | null {
+  if (parsed.some(({ isLoading }) => isLoading)) return null;
+  const cutoff = new Date(now - NINETY_DAYS_MS);
+  let buyShares = 0;
+  let sellShares = 0;
+  let buyValue = 0;
+  let sellValue = 0;
+
+  for (const { transaction } of parsed) {
+    if (!transaction) continue;
+    const txDate = transaction.filingDate instanceof Date
+      ? transaction.filingDate
+      : new Date(transaction.filingDate);
+    if (Number.isNaN(txDate.getTime()) || txDate < cutoff) continue;
+    if (transaction.transactionType === "P") {
+      buyShares += transaction.shares;
+      buyValue += transaction.totalValue ?? 0;
+    } else if (transaction.transactionType === "S") {
+      sellShares += transaction.shares;
+      sellValue += transaction.totalValue ?? 0;
+    }
+  }
+
+  if (buyShares === 0 && sellShares === 0) return "No buy/sell activity in last 90 days.";
+
+  const parts: string[] = [];
+  if (buyShares > 0) parts.push(`Bought ${formatCompact(buyShares)} shares (${formatCurrency(buyValue)})`);
+  if (sellShares > 0) parts.push(`Sold ${formatCompact(sellShares)} shares (${formatCurrency(sellValue)})`);
+  return parts.join("  |  ");
+}
+
+export function buildInsiderRows(parsed: readonly ParsedInsiderFiling[]) {
+  return parsed.map(({ filing, transaction, isLoading }) => ({
+    filingDate: filing.filingDate instanceof Date
+      ? filing.filingDate.toISOString()
+      : String(filing.filingDate),
+    transactionDate: transaction?.filingDate instanceof Date
+      ? transaction.filingDate.toISOString()
+      : transaction?.filingDate ? String(transaction.filingDate) : null,
+    insider: transaction?.reportedName ?? null,
+    title: transaction?.title ?? null,
+    side: transaction ? transactionTypeLabel(transaction.transactionType) : null,
+    transactionCode: transaction?.transactionType ?? null,
+    shares: transaction?.shares ?? null,
+    pricePerShare: transaction?.pricePerShare ?? null,
+    totalValue: transaction?.totalValue ?? null,
+    sharesOwnedAfter: transaction?.sharesOwned ?? null,
+    form: filing.form,
+    accessionNumber: filing.accessionNumber,
+    url: filing.filingUrl,
+    status: isLoading ? "loading" : transaction ? "parsed" : "unavailable",
+  }));
+}

package/src/plugins/builtin/ipo-calendar/client.ts

@@ -256,6 +256,21 @@ async function fetchUpcomingIpos(): Promise<IPORecord[]> {
   return parseCalendarRecords(flat);
 }
 
+export function formatIpoDate(date: Date): string {
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  return `${date.getUTCFullYear()}-${month}-${day}`;
+}
+
+export function matchesIpoRecord(record: IPORecord, query: string): boolean {
+  if (!query) return true;
+  const normalized = query.toLowerCase();
+  return record.ticker.toLowerCase().includes(normalized)
+    || record.companyName.toLowerCase().includes(normalized)
+    || (record.exchange?.toLowerCase().includes(normalized) ?? false)
+    || record.status.includes(normalized);
+}
+
 function dedupeAndSort(records: IPORecord[]): IPORecord[] {
   const byTicker = new Map<string, IPORecord>();
   const statusOrder: Record<IPOStatus, number> = { upcoming: 0, priced: 1, trading: 2 };

package/src/plugins/builtin/ipo-calendar/headless.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
+import { createIpoCalendarHeadless } from "./headless";
+import type { IPORecord } from "./types";
+
+const records: IPORecord[] = [
+  {
+    ticker: "ALFA",
+    companyName: "Alpha Labs",
+    date: new Date("2026-09-10T00:00:00.000Z"),
+    status: "upcoming",
+    exchange: "NASDAQ",
+    offerSize: 120_000_000,
+    priceRange: [18, 20],
+    pricedPrice: null,
+    shares: 6_000_000,
+    closePrice: null,
+    change1D: null,
+  },
+  {
+    ticker: "BETA",
+    companyName: "Beta Systems",
+    date: new Date("2026-09-03T00:00:00.000Z"),
+    status: "trading",
+    exchange: "NYSE",
+    offerSize: null,
+    priceRange: null,
+    pricedPrice: 24,
+    shares: null,
+    closePrice: 30,
+    change1D: 25,
+  },
+];
+
+function args(
+  argument: string | null = null,
+  options: Record<string, string | number | boolean> = { status: "all", limit: 50 },
+): HeadlessPaneLoadArgs {
+  return {
+    rawArgument: argument ?? "",
+    argument,
+    symbols: [],
+    options,
+  };
+}
+
+const context = {} as HeadlessPaneContext;
+
+describe("IPO calendar headless", () => {
+  test("maps IPO records into structured rows", async () => {
+    const definition = createIpoCalendarHeadless({
+      loadCalendar: async () => ({
+        records,
+        fetchedAt: 123,
+        stale: false,
+        errors: [],
+      }),
+    });
+
+    const result = await definition.load(args("alpha"), context);
+
+    expect(result.rows).toEqual([{
+      ticker: "ALFA",
+      company: "Alpha Labs",
+      date: "2026-09-10",
+      status: "upcoming",
+      exchange: "NASDAQ",
+      offerSize: 120_000_000,
+      priceLow: 18,
+      priceHigh: 20,
+      pricedPrice: null,
+      shares: 6_000_000,
+      closePrice: null,
+      change1D: null,
+    }]);
+    expect(result.metadata).toMatchObject({ total: 1, returned: 1, truncated: false });
+  });
+
+  test("applies status and limit options", async () => {
+    const definition = createIpoCalendarHeadless({
+      loadCalendar: async () => ({ records, fetchedAt: 123, stale: false, errors: [] }),
+    });
+
+    const result = await definition.load(args(null, { status: "trading", limit: 1 }), context);
+
+    expect(result.rows.map((row) => row.ticker)).toEqual(["BETA"]);
+    expect(result.metadata).toMatchObject({ status: "trading", returned: 1 });
+  });
+});

package/src/plugins/builtin/ipo-calendar/headless.ts

@@ -0,0 +1,127 @@
+import type {
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+  HeadlessRowsResult,
+} from "../../../types/plugin";
+import { formatIpoDate, matchesIpoRecord } from "./client";
+import { loadIpoCalendar, type IpoCalendarResult } from "./cache";
+import type { IPORecord, IPOStatus } from "./types";
+
+const IPO_COLUMNS = [
+  { key: "ticker", header: "Ticker" },
+  { key: "company", header: "Company" },
+  { key: "date", header: "Date" },
+  { key: "status", header: "Status" },
+  { key: "exchange", header: "Exchange" },
+  { key: "offerSize", header: "Offer", align: "right" as const },
+  { key: "priceLow", header: "Price low", align: "right" as const },
+  { key: "priceHigh", header: "Price high", align: "right" as const },
+  { key: "pricedPrice", header: "Priced", align: "right" as const },
+  { key: "shares", header: "Shares", align: "right" as const },
+  { key: "closePrice", header: "Close", align: "right" as const },
+  { key: "change1D", header: "1D %", align: "right" as const },
+];
+
+export interface IpoCalendarHeadlessDependencies {
+  loadCalendar(): Promise<IpoCalendarResult>;
+}
+
+const defaultDependencies: IpoCalendarHeadlessDependencies = {
+  loadCalendar: () => loadIpoCalendar(false),
+};
+
+function statusOption(args: HeadlessPaneLoadArgs): IPOStatus | "all" {
+  return String(args.options.status ?? "all") as IPOStatus | "all";
+}
+
+function toHeadlessRow(record: IPORecord) {
+  return {
+    ticker: record.ticker,
+    company: record.companyName,
+    date: formatIpoDate(record.date),
+    status: record.status,
+    exchange: record.exchange,
+    offerSize: record.offerSize,
+    priceLow: record.priceRange?.[0] ?? null,
+    priceHigh: record.priceRange?.[1] ?? null,
+    pricedPrice: record.pricedPrice,
+    shares: record.shares,
+    closePrice: record.closePrice,
+    change1D: record.change1D,
+  };
+}
+
+export function projectIpoCalendarHeadless(
+  result: IpoCalendarResult,
+  args: HeadlessPaneLoadArgs,
+): HeadlessRowsResult {
+  const query = typeof args.argument === "string" ? args.argument.trim() : "";
+  const status = statusOption(args);
+  const limit = Number(args.options.limit ?? 50);
+  const matching = result.records.filter((record) => (
+    matchesIpoRecord(record, query)
+    && (status === "all" || record.status === status)
+  ));
+  const rows = matching.slice(0, limit).map(toHeadlessRow);
+
+  return {
+    columns: IPO_COLUMNS,
+    rows,
+    errors: result.errors.length > 0 ? result.errors : undefined,
+    metadata: {
+      fetchedAt: result.fetchedAt,
+      stale: result.stale,
+      total: matching.length,
+      returned: rows.length,
+      truncated: rows.length < matching.length,
+      query: query || null,
+      status,
+    },
+  };
+}
+
+export function createIpoCalendarHeadless(
+  dependencies: IpoCalendarHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"rows"> {
+  return {
+    shape: "rows",
+    argument: {
+      kind: "free-text",
+      placeholder: "company or ticker",
+      description: "Optional company, ticker, exchange, or status filter.",
+      optional: true,
+    },
+    options: [
+      {
+        key: "status",
+        description: "IPO stage to include.",
+        type: "enum",
+        values: [
+          { value: "all" },
+          { value: "upcoming" },
+          { value: "priced" },
+          { value: "trading" },
+        ],
+        defaultValue: "all",
+      },
+      {
+        key: "limit",
+        description: "Maximum IPO rows to return.",
+        type: "integer",
+        defaultValue: 50,
+        minimum: 1,
+        maximum: 200,
+      },
+    ],
+    columns: IPO_COLUMNS,
+    describe: (args) => {
+      const status = statusOption(args);
+      return status === "all" ? "IPO Calendar" : `IPO Calendar | ${status}`;
+    },
+    async load(args) {
+      return projectIpoCalendarHeadless(await dependencies.loadCalendar(), args);
+    },
+  };
+}
+
+export const ipoCalendarHeadless = createIpoCalendarHeadless();

package/src/plugins/builtin/ipo-calendar/index.tsx

@@ -6,6 +6,7 @@ import {
 } from "./client";
 import { attachIpoCalendarPersistence, resetIpoCalendarPersistence } from "./cache";
 import { IPOCalendarPane } from "./pane";
+import { ipoCalendarHeadless } from "./headless";
 import { IPO_CALENDAR_PANE_ID } from "./types";
 
 let disposeConnection: (() => void) | null = null;
@@ -60,6 +61,7 @@ export const ipoCalendarModule: PluginModule = {
         "debut",
       ],
       shortcut: { prefix: "IPO" },
+      headless: ipoCalendarHeadless,
       createInstance: () => ({ placement: "floating" }),
     },
   ],

package/src/plugins/builtin/ipo-calendar/model.ts

@@ -2,6 +2,7 @@ import type { DataTableColumn } from "../../../components";
 import { colors } from "../../../theme/colors";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
 import type { IPORecord, IPOStatus } from "./types";
+import { formatIpoDate, matchesIpoRecord } from "./client";
 
 type IPOColumnId =
   | "ticker"
@@ -37,11 +38,7 @@ export function statusColor(status: IPOStatus): string {
   }
 }
 
-export function formatDate(date: Date): string {
-  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(date.getUTCDate()).padStart(2, "0");
-  return `${date.getUTCFullYear()}-${month}-${day}`;
-}
+export const formatDate = formatIpoDate;
 
 export function formatOfferSize(value: number | null): string {
   if (value == null) return "—";
@@ -133,13 +130,4 @@ export function nextSortPreference(current: IPOSortPreference, columnId: string)
   return DEFAULT_SORT_PREFERENCE;
 }
 
-export function matchesSearch(record: IPORecord, query: string): boolean {
-  if (!query) return true;
-  const q = query.toLowerCase();
-  return (
-    record.ticker.toLowerCase().includes(q)
-    || record.companyName.toLowerCase().includes(q)
-    || (record.exchange?.toLowerCase().includes(q) ?? false)
-    || record.status.includes(q)
-  );
-}
+export const matchesSearch = matchesIpoRecord;

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