gloomberb 0.10.4 → 0.11.0

package/src/plugins/builtin/treasury-auctions/index.tsx

@@ -0,0 +1,90 @@
+import type { PaneSettingsDef } from "../../../types/plugin";
+import type { PluginModule } from "../plugin-module";
+import {
+  attachTreasuryAuctionsPersistence,
+  resetTreasuryAuctionsPersistence,
+  TREASURY_FISCAL_DATA_CONNECTION_ID,
+} from "./cache";
+import { TreasuryAuctionsPane } from "./pane";
+import { TREASURY_AUCTIONS_PANE_ID } from "./types";
+
+let disposeConnection: (() => void) | null = null;
+
+function treasuryAuctionsSettings(): PaneSettingsDef {
+  return {
+    title: "Treasury Auctions Settings",
+    fields: [
+      {
+        key: "historyDays",
+        label: "History window",
+        description: "How far back auction results are requested.",
+        type: "select",
+        options: [
+          { value: "30", label: "30 days" },
+          { value: "90", label: "90 days" },
+          { value: "120", label: "120 days" },
+          { value: "365", label: "1 year" },
+        ],
+      },
+    ],
+  };
+}
+
+export const treasuryAuctionsModule: PluginModule = {
+  setup(ctx) {
+    attachTreasuryAuctionsPersistence(ctx.persistence, ctx.connectionHealth);
+    disposeConnection = ctx.connectionHealth.registerSource({
+      id: TREASURY_FISCAL_DATA_CONNECTION_ID,
+      name: "Treasury Fiscal Data",
+      kind: "api",
+      ownerId: "macro",
+      priority: 300,
+      detail: "fiscaldata.treasury.gov",
+    });
+  },
+
+  dispose() {
+    disposeConnection?.();
+    disposeConnection = null;
+    resetTreasuryAuctionsPersistence();
+  },
+
+  panes: [
+    {
+      id: TREASURY_AUCTIONS_PANE_ID,
+      name: "Treasury Auctions",
+      icon: "A",
+      component: TreasuryAuctionsPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 92, height: 28 },
+      settings: treasuryAuctionsSettings(),
+    },
+  ],
+
+  paneTemplates: [
+    {
+      id: "treasury-auctions-pane",
+      paneId: TREASURY_AUCTIONS_PANE_ID,
+      label: "Treasury Auctions",
+      description:
+        "Bill, note, bond, and TIPS auction results from Treasury Fiscal Data: high rate, bid-to-cover, indirect share, and size.",
+      keywords: [
+        "treasury",
+        "auction",
+        "auctions",
+        "bills",
+        "notes",
+        "bonds",
+        "tips",
+        "frn",
+        "bid",
+        "cover",
+        "indirect",
+        "issuance",
+      ],
+      shortcut: { prefix: "AUCT" },
+      createInstance: () => ({ placement: "floating" }),
+    },
+  ],
+};

package/src/plugins/builtin/treasury-auctions/model.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+import {
+  DEFAULT_AUCTION_SORT,
+  indirectPct,
+  isPendingAuction,
+  matchesFilter,
+  nextAuctionSort,
+  nextFilter,
+  rateValue,
+  termLengthDays,
+  visibleAuctions,
+} from "./model";
+import type { TreasuryAuction } from "./types";
+
+function auction(overrides: Partial<TreasuryAuction> & { secType: string; securityTerm: string }): TreasuryAuction {
+  return {
+    id: `${overrides.secType}|${overrides.auctionDate ?? "2026-08-12"}|${overrides.securityTerm}`,
+    auctionDate: "2026-08-12",
+    highInvestmentRate: null,
+    highYield: null,
+    avgMedYield: null,
+    highPrice: null,
+    lowPrice: null,
+    avgMedPrice: null,
+    bidToCoverRatio: null,
+    competitiveAccepted: null,
+    indirectAccepted: null,
+    primaryDealerAccepted: null,
+    totalAccepted: null,
+    offeringAmount: null,
+    ...overrides,
+  };
+}
+
+describe("term ordering", () => {
+  test("orders the curve by length, not alphabetically", () => {
+    const terms = ["30-Year", "4-Week", "10-Year", "182-Day", "2-Year", "6-Month", "29-Year 6-Month"];
+    const sorted = [...terms].sort((left, right) => termLengthDays(left) - termLengthDays(right));
+    expect(sorted).toEqual(["4-Week", "6-Month", "182-Day", "2-Year", "10-Year", "29-Year 6-Month", "30-Year"]);
+  });
+
+  test("sends unparseable terms to the end rather than to the front", () => {
+    expect(termLengthDays("Cash Management")).toBe(Number.MAX_SAFE_INTEGER);
+    expect(termLengthDays("")).toBe(Number.MAX_SAFE_INTEGER);
+  });
+});
+
+describe("auction metrics", () => {
+  test("reads the rate each security type actually reports", () => {
+    expect(rateValue(auction({ secType: "Bill", securityTerm: "4-Week", highInvestmentRate: 3.9 }))).toBe(3.9);
+    expect(rateValue(auction({ secType: "Note", securityTerm: "10-Year", highYield: 4.683 }))).toBe(4.683);
+    expect(rateValue(auction({ secType: "Bond", securityTerm: "20-Year" }))).toBeNull();
+  });
+
+  test("keeps a zero indirect allocation as 0%, not unknown", () => {
+    // A no-indirect auction is a real result and a notable one; "—" hides it.
+    const zeroIndirect = auction({
+      secType: "Bill",
+      securityTerm: "4-Week",
+      indirectAccepted: 0,
+      totalAccepted: 50_000_000_000,
+    });
+    expect(indirectPct(zeroIndirect)).toBe(0);
+    expect(visibleAuctions([zeroIndirect], {
+      filter: "all",
+      query: "",
+      sort: { columnId: "indirect", direction: "desc" },
+    })).toHaveLength(1);
+  });
+
+  test("indirect share needs both legs and survives a zero total", () => {
+    const filled = auction({
+      secType: "Note",
+      securityTerm: "10-Year",
+      indirectAccepted: 32_087_936_000,
+      totalAccepted: 52_623_557_100,
+    });
+    expect(indirectPct(filled)).toBeCloseTo(60.98, 1);
+    expect(indirectPct(auction({ secType: "Note", securityTerm: "10-Year", totalAccepted: 0, indirectAccepted: 5 })))
+      .toBeNull();
+    expect(indirectPct(auction({ secType: "Note", securityTerm: "10-Year", totalAccepted: 100 }))).toBeNull();
+  });
+
+  test("flags announced auctions that have no published results", () => {
+    expect(isPendingAuction(auction({ secType: "Bond", securityTerm: "20-Year" }))).toBe(true);
+    expect(isPendingAuction(auction({ secType: "Bond", securityTerm: "20-Year", bidToCoverRatio: 2.4 }))).toBe(false);
+  });
+});
+
+describe("filters", () => {
+  test("groups CMBs with bills, FRNs with notes, and TIPS with bonds", () => {
+    expect(matchesFilter(auction({ secType: "CMB", securityTerm: "42-Day" }), "bill")).toBe(true);
+    expect(matchesFilter(auction({ secType: "FRN", securityTerm: "2-Year" }), "note")).toBe(true);
+    expect(matchesFilter(auction({ secType: "TIPS", securityTerm: "10-Year" }), "bond")).toBe(true);
+    expect(matchesFilter(auction({ secType: "TIPS", securityTerm: "10-Year" }), "note")).toBe(false);
+    expect(matchesFilter(auction({ secType: "TIPS", securityTerm: "10-Year" }), "all")).toBe(true);
+  });
+
+  test("the filter key wraps through every tab", () => {
+    expect(nextFilter("all")).toBe("bill");
+    expect(nextFilter(nextFilter(nextFilter("bill")))).toBe("all");
+  });
+});
+
+describe("visibleAuctions", () => {
+  const rows = [
+    auction({ secType: "Bill", securityTerm: "4-Week", auctionDate: "2026-08-17", highInvestmentRate: 3.9 }),
+    auction({ secType: "Note", securityTerm: "10-Year", auctionDate: "2026-08-12", highYield: 4.683 }),
+    auction({ secType: "Bond", securityTerm: "30-Year", auctionDate: "2026-08-14", highYield: 5.1 }),
+  ];
+
+  test("newest first by default", () => {
+    expect(visibleAuctions(rows, { filter: "all", query: "", sort: DEFAULT_AUCTION_SORT })
+      .map((row) => row.auctionDate)).toEqual(["2026-08-17", "2026-08-14", "2026-08-12"]);
+  });
+
+  test("term sort walks the curve, not the alphabet", () => {
+    expect(visibleAuctions(rows, { filter: "all", query: "", sort: { columnId: "term", direction: "asc" } })
+      .map((row) => row.securityTerm)).toEqual(["4-Week", "10-Year", "30-Year"]);
+  });
+
+  test("search matches type, term, and auction date", () => {
+    const sort = DEFAULT_AUCTION_SORT;
+    expect(visibleAuctions(rows, { filter: "all", query: "bill", sort })).toHaveLength(1);
+    expect(visibleAuctions(rows, { filter: "all", query: "30-year", sort })).toHaveLength(1);
+    expect(visibleAuctions(rows, { filter: "all", query: "2026-08-1", sort })).toHaveLength(3);
+    expect(visibleAuctions(rows, { filter: "note", query: "bill", sort })).toHaveLength(0);
+  });
+
+  test("rows missing a metric sort last instead of jumping to the top", () => {
+    const withPending = [...rows, auction({ secType: "Bond", securityTerm: "20-Year", auctionDate: "2026-08-19" })];
+    const byRate = visibleAuctions(withPending, {
+      filter: "all",
+      query: "",
+      sort: { columnId: "rate", direction: "desc" },
+    });
+    expect(byRate.at(-1)?.securityTerm).toBe("20-Year");
+  });
+});
+
+describe("nextAuctionSort", () => {
+  test("toggles direction on the active column and picks a sane default per column", () => {
+    expect(nextAuctionSort(DEFAULT_AUCTION_SORT, "date")).toEqual({ columnId: "date", direction: "asc" });
+    expect(nextAuctionSort(DEFAULT_AUCTION_SORT, "btc")).toEqual({ columnId: "btc", direction: "desc" });
+    expect(nextAuctionSort(DEFAULT_AUCTION_SORT, "term")).toEqual({ columnId: "term", direction: "asc" });
+  });
+});

package/src/plugins/builtin/treasury-auctions/model.ts

@@ -0,0 +1,188 @@
+import type { DataTableColumn } from "../../../components";
+import type { SortDirection } from "../../../utils/sort-values";
+import { AUCTION_HISTORY_DAYS } from "./client";
+import type { TreasuryAuction } from "./types";
+
+/** Windows the Fiscal Data query supports without paging past MAX_PAGES. */
+export const AUCTION_HISTORY_WINDOWS = [30, 90, 120, 365] as const;
+
+/** Pane settings arrive as unvalidated strings, so anything unknown falls back. */
+export function auctionHistoryDays(settings: Record<string, unknown> | undefined): number {
+  const value = Number(settings?.historyDays);
+  return (AUCTION_HISTORY_WINDOWS as readonly number[]).includes(value) ? value : AUCTION_HISTORY_DAYS;
+}
+
+export type AuctionColumnId = "date" | "type" | "term" | "rate" | "btc" | "indirect" | "size";
+
+export interface AuctionColumn extends DataTableColumn {
+  id: AuctionColumnId;
+}
+
+export interface AuctionSortPreference {
+  columnId: AuctionColumnId;
+  direction: SortDirection;
+}
+
+export const DEFAULT_AUCTION_SORT: AuctionSortPreference = {
+  columnId: "date",
+  direction: "desc",
+};
+
+export const AUCTION_SORT_COLUMN_IDS: readonly AuctionColumnId[] = [
+  "date",
+  "type",
+  "term",
+  "rate",
+  "btc",
+  "indirect",
+  "size",
+];
+
+export type AuctionFilter = "all" | "bill" | "note" | "bond";
+
+export const AUCTION_FILTERS: ReadonlyArray<{ value: AuctionFilter; label: string }> = [
+  { value: "all", label: "All" },
+  { value: "bill", label: "Bills" },
+  { value: "note", label: "Notes" },
+  { value: "bond", label: "Bonds" },
+];
+
+// CMBs are cash management bills; FRNs are issued off the 2-year note; TIPS
+// are auctioned as notes and bonds but group with the long end here.
+const FILTER_TYPES: Record<Exclude<AuctionFilter, "all">, ReadonlySet<string>> = {
+  bill: new Set(["Bill", "CMB"]),
+  note: new Set(["Note", "FRN"]),
+  bond: new Set(["Bond", "TIPS"]),
+};
+
+export function matchesFilter(auction: TreasuryAuction, filter: AuctionFilter): boolean {
+  return filter === "all" || FILTER_TYPES[filter].has(auction.secType);
+}
+
+export function nextFilter(current: AuctionFilter): AuctionFilter {
+  const index = AUCTION_FILTERS.findIndex((entry) => entry.value === current);
+  return AUCTION_FILTERS[(index + 1) % AUCTION_FILTERS.length]!.value;
+}
+
+function matchesAuctionQuery(auction: TreasuryAuction, query: string): boolean {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) return true;
+  return (
+    auction.secType.toLowerCase().includes(normalized)
+    || auction.securityTerm.toLowerCase().includes(normalized)
+    || auction.auctionDate.includes(normalized)
+  );
+}
+
+function auctionDateValue(value: string): number {
+  const timestamp = Date.parse(`${value}T00:00:00Z`);
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
+
+/**
+ * Term length in days so "4-Week" sorts before "10-Year" instead of
+ * alphabetically. "29-Year 6-Month" only needs its leading unit to order
+ * correctly against the rest of the curve.
+ */
+export function termLengthDays(term: string): number {
+  const match = term.match(/^(\d+)\s*-\s*(Day|Week|Month|Year)/i);
+  if (!match) return Number.MAX_SAFE_INTEGER;
+  const count = Number(match[1]);
+  switch (match[2]!.toLowerCase()) {
+    case "day": return count;
+    case "week": return count * 7;
+    case "month": return count * 30;
+    default: return count * 365;
+  }
+}
+
+/**
+ * Zero indirect bidding is a real, and notable, auction outcome, so only a
+ * missing leg or an unusable total is unknown.
+ */
+export function indirectPct(auction: TreasuryAuction): number | null {
+  if (auction.indirectAccepted == null || !auction.totalAccepted) return null;
+  return (auction.indirectAccepted / auction.totalAccepted) * 100;
+}
+
+/**
+ * The headline rate: Bills and FRNs report a high investment rate, Notes,
+ * Bonds, and TIPS report a high yield.
+ */
+export function rateValue(auction: TreasuryAuction): number | null {
+  return auction.highInvestmentRate ?? auction.highYield;
+}
+
+/** Announced auctions appear in the feed days before any results are published. */
+export function isPendingAuction(auction: TreasuryAuction): boolean {
+  return rateValue(auction) == null && auction.bidToCoverRatio == null;
+}
+
+export function auctionSize(auction: TreasuryAuction): number | null {
+  return auction.totalAccepted ?? auction.offeringAmount;
+}
+
+function sortValue(auction: TreasuryAuction, columnId: AuctionColumnId): number | string {
+  switch (columnId) {
+    case "date": return auctionDateValue(auction.auctionDate);
+    case "type": return auction.secType;
+    case "term": return termLengthDays(auction.securityTerm);
+    case "rate": return rateValue(auction) ?? Number.NEGATIVE_INFINITY;
+    case "btc": return auction.bidToCoverRatio ?? Number.NEGATIVE_INFINITY;
+    case "indirect": return indirectPct(auction) ?? Number.NEGATIVE_INFINITY;
+    case "size": return auctionSize(auction) ?? Number.NEGATIVE_INFINITY;
+  }
+}
+
+export function visibleAuctions(
+  auctions: readonly TreasuryAuction[],
+  options: { filter: AuctionFilter; query: string; sort: AuctionSortPreference },
+): TreasuryAuction[] {
+  const direction = options.sort.direction === "asc" ? 1 : -1;
+  return auctions
+    .filter((auction) => matchesFilter(auction, options.filter) && matchesAuctionQuery(auction, options.query))
+    .sort((left, right) => {
+      const leftValue = sortValue(left, options.sort.columnId);
+      const rightValue = sortValue(right, options.sort.columnId);
+      const comparison = typeof leftValue === "string" && typeof rightValue === "string"
+        ? leftValue.localeCompare(rightValue, "en-US", { sensitivity: "base" })
+        : Number(leftValue) - Number(rightValue);
+      if (comparison !== 0) return comparison * direction;
+      // Ties keep the newest auction on top regardless of sort direction.
+      return auctionDateValue(right.auctionDate) - auctionDateValue(left.auctionDate);
+    });
+}
+
+export function nextAuctionSort(
+  current: AuctionSortPreference,
+  columnId: AuctionColumnId,
+): AuctionSortPreference {
+  if (current.columnId === columnId) {
+    const direction: SortDirection = current.direction === "asc" ? "desc" : "asc";
+    return { columnId, direction };
+  }
+  // Text columns read best ascending; every metric reads best highest-first.
+  return { columnId, direction: columnId === "type" || columnId === "term" ? "asc" : "desc" };
+}
+
+export function buildAuctionColumns(width: number): AuctionColumn[] {
+  const dateWidth = 8;
+  const typeWidth = 6;
+  const rateWidth = 8;
+  const btcWidth = 6;
+  const indirectWidth = 9;
+  const sizeWidth = 8;
+  const termWidth = Math.max(
+    10,
+    width - dateWidth - typeWidth - rateWidth - btcWidth - indirectWidth - sizeWidth - 8,
+  );
+  return [
+    { id: "date", label: "DATE", width: dateWidth, align: "left" },
+    { id: "type", label: "TYPE", width: typeWidth, align: "left" },
+    { id: "term", label: "TERM", width: termWidth, align: "left" },
+    { id: "rate", label: "RATE", width: rateWidth, align: "right" },
+    { id: "btc", label: "B/C", width: btcWidth, align: "right" },
+    { id: "indirect", label: "INDIRECT", width: indirectWidth, align: "right" },
+    { id: "size", label: "SIZE", width: sizeWidth, align: "right" },
+  ];
+}

package/src/plugins/builtin/treasury-auctions/pane.test.tsx

@@ -0,0 +1,170 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import { AppContext, createInitialState, PaneInstanceProvider } from "../../../state/app/context";
+import { createDefaultConfig } from "../../../types/config";
+import type { PluginPersistence } from "../../../types/plugin";
+import {
+  attachTreasuryAuctionsPersistence,
+  resetTreasuryAuctionsPersistence,
+} from "./cache";
+import { TreasuryAuctionsPane } from "./pane";
+import type { TreasuryAuction } from "./types";
+
+function auction(overrides: Partial<TreasuryAuction> & { secType: string; securityTerm: string }): TreasuryAuction {
+  return {
+    id: `${overrides.secType}|${overrides.auctionDate ?? "2026-08-12"}|${overrides.securityTerm}`,
+    auctionDate: "2026-08-12",
+    highInvestmentRate: null,
+    highYield: null,
+    avgMedYield: null,
+    highPrice: null,
+    lowPrice: null,
+    avgMedPrice: null,
+    bidToCoverRatio: null,
+    competitiveAccepted: null,
+    indirectAccepted: null,
+    primaryDealerAccepted: null,
+    totalAccepted: null,
+    offeringAmount: null,
+    ...overrides,
+  };
+}
+
+const AUCTIONS: TreasuryAuction[] = [
+  auction({
+    secType: "Bond",
+    securityTerm: "20-Year",
+    auctionDate: "2026-08-19",
+    offeringAmount: 16_000_000_000,
+  }),
+  auction({
+    secType: "Bill",
+    securityTerm: "13-Week",
+    auctionDate: "2026-08-17",
+    highInvestmentRate: 3.802,
+    bidToCoverRatio: 2.86,
+    indirectAccepted: 48_000_000_000,
+    totalAccepted: 98_725_863_900,
+  }),
+  auction({
+    secType: "Note",
+    securityTerm: "10-Year",
+    auctionDate: "2026-08-12",
+    highYield: 4.683,
+    bidToCoverRatio: 2.53,
+    indirectAccepted: 32_087_936_000,
+    primaryDealerAccepted: 3_597_810_000,
+    totalAccepted: 52_623_557_100,
+  }),
+];
+
+/** Fresh cache so the pane renders without touching the Treasury endpoint. */
+function seedCache(): void {
+  attachTreasuryAuctionsPersistence({
+    getResource: () => ({ value: AUCTIONS, fetchedAt: Date.now(), stale: false }),
+    setResource: () => ({ value: AUCTIONS, fetchedAt: Date.now(), stale: false }),
+  } as unknown as PluginPersistence);
+}
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+afterEach(async () => {
+  resetTreasuryAuctionsPersistence();
+  if (!testSetup) return;
+  await act(async () => {
+    testSetup!.renderer.destroy();
+  });
+  testSetup = undefined;
+});
+
+function Harness() {
+  const state = createInitialState(createDefaultConfig("/tmp/gloomberb-auctions-pane-test"));
+  return (
+    <AppContext value={{ state, dispatch: () => {} }}>
+      <PaneInstanceProvider paneId="treasury-auctions">
+        <TreasuryAuctionsPane
+          paneId="treasury-auctions"
+          paneType="treasury-auctions"
+          focused
+          width={92}
+          height={20}
+        />
+      </PaneInstanceProvider>
+    </AppContext>
+  );
+}
+
+async function renderSettled() {
+  await act(async () => {
+    await testSetup!.renderOnce();
+    await testSetup!.renderOnce();
+  });
+}
+
+async function emitKeypress(event: { name?: string; sequence?: string }) {
+  await act(async () => {
+    testSetup!.renderer.keyInput.emit("keypress", {
+      ctrl: false,
+      meta: false,
+      option: false,
+      shift: false,
+      eventType: "press",
+      repeated: false,
+      defaultPrevented: false,
+      propagationStopped: false,
+      preventDefault: () => {},
+      stopPropagation: () => {},
+      ...event,
+    } as never);
+    await testSetup!.renderOnce();
+  });
+}
+
+describe("TreasuryAuctionsPane", () => {
+  test("renders auction metrics and keeps one placeholder for unpublished results", async () => {
+    seedCache();
+    testSetup = await testRender(<Harness />, { width: 92, height: 20 });
+    await renderSettled();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("13-Week");
+    expect(frame).toContain("3.802%");
+    expect(frame).toContain("2.86");
+    // Indirect share is derived, not reported.
+    expect(frame).toContain("48.6%");
+    // The 20-Year is announced but unpublished: every metric cell reads the
+    // same placeholder the reported-but-missing cells use.
+    expect(frame).toContain("20-Year");
+    expect(frame).not.toContain("pending");
+  });
+
+  test("opens a detail view for the selected auction", async () => {
+    seedCache();
+    testSetup = await testRender(<Harness />, { width: 92, height: 20 });
+    await renderSettled();
+
+    await emitKeypress({ name: "down", sequence: "\u001B[B" });
+    await emitKeypress({ name: "enter", sequence: "\r" });
+    await renderSettled();
+
+    const detail = testSetup.captureCharFrame();
+    expect(detail).toContain("Bill 13-Week");
+    expect(detail).toContain("Bid-to-cover");
+    expect(detail).toContain("Total accepted");
+  });
+
+  test("the filter key narrows the board to one security group", async () => {
+    seedCache();
+    testSetup = await testRender(<Harness />, { width: 92, height: 20 });
+    await renderSettled();
+
+    // all -> bills
+    await emitKeypress({ name: "f", sequence: "f" });
+    await renderSettled();
+
+    const bills = testSetup.captureCharFrame();
+    expect(bills).toContain("13-Week");
+    expect(bills).not.toContain("10-Year");
+  });
+});