gloomberb 0.11.3 → 0.12.0

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

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import { splitFigures, splitSentences } from "./prose";
+
+describe("splitFigures", () => {
+  test("picks out money, percentages and quantities, leaves years and labels", () => {
+    const runs = splitFigures(
+      "Revenue grew 20% to $1.2 billion in 2026, or 150 bps above Q2 guidance of $900 million to $1 billion, with 2,500 hires.",
+    );
+    expect(runs.filter((run) => run.figure).map((run) => run.text)).toEqual([
+      "20%",
+      "$1.2 billion",
+      "150 bps",
+      "$900 million",
+      "$1 billion",
+      "2,500",
+    ]);
+    // Everything is accounted for, nothing dropped or duplicated.
+    expect(runs.map((run) => run.text).join("")).toBe(
+      "Revenue grew 20% to $1.2 billion in 2026, or 150 bps above Q2 guidance of $900 million to $1 billion, with 2,500 hires.",
+    );
+  });
+});
+
+describe("splitSentences", () => {
+  test("splits on sentence ends but not on abbreviations or decimals", () => {
+    expect(
+      splitSentences(
+        "The U.S. business grew. Margins were 27.8% vs. 25% last year. Acme Inc. expects $5 million and under; management sees this as transferable.",
+      ),
+    ).toEqual([
+      "The U.S. business grew.",
+      "Margins were 27.8% vs. 25% last year.",
+      "Acme Inc. expects $5 million and under; management sees this as transferable.",
+    ]);
+  });
+});

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

@@ -0,0 +1,59 @@
+/**
+ * Text shaping for the call reader. Model summaries arrive as dense
+ * paragraphs; on a wide pane they are a wall. Splitting them into one point
+ * per sentence and setting the figures in bold is what makes them scannable.
+ */
+
+export interface ProseRun {
+  text: string;
+  /** A number the eye should land on: money, percentages, quantities. */
+  figure: boolean;
+}
+
+/**
+ * Money, percentages and quantities with a unit, plus bare numbers except
+ * years. Ordinals and fiscal labels (Q2, FY26, 2Q) are left alone.
+ */
+const FIGURE_PATTERN =
+  /[$€£¥]\s?\d[\d,]*(?:\.\d+)?(?:\s?(?:trillion|billion|million|thousand|bn|mn|k|m|b)\b)?|\b\d[\d,]*(?:\.\d+)?\s?(?:%|percent(?:age points?)?|bps|basis points|x\b|trillion|billion|million|thousand)|\b\d[\d,]*(?:\.\d+)?\b/gi;
+
+const YEAR_PATTERN = /^(?:19|20)\d{2}$/;
+
+export function splitFigures(text: string): ProseRun[] {
+  const runs: ProseRun[] = [];
+  let last = 0;
+  for (const match of text.matchAll(FIGURE_PATTERN)) {
+    const start = match.index ?? 0;
+    const value = match[0];
+    if (YEAR_PATTERN.test(value)) continue;
+    if (start > last) runs.push({ text: text.slice(last, start), figure: false });
+    runs.push({ text: value, figure: true });
+    last = start + value.length;
+  }
+  if (last < text.length) runs.push({ text: text.slice(last), figure: false });
+  return runs;
+}
+
+/**
+ * Sentence boundaries, minus the periods inside abbreviations ("U.S.",
+ * "Inc.", "vs.") and figures ("$27.8 million").
+ */
+const SENTENCE_BOUNDARY =
+  /(?<!\b(?:[A-Z]|Inc|Ltd|Co|Corp|vs|Mr|Ms|Mrs|Dr|No|St|Jr|Sr|U\.S|e\.g|i\.e|approx))[.!?]["”')]?\s+(?=["“(]?[A-Z0-9$])/;
+
+export function splitSentences(text: string): string[] {
+  const out: string[] = [];
+  let rest = text.trim();
+  while (rest.length > 0) {
+    const match = SENTENCE_BOUNDARY.exec(rest);
+    if (!match) {
+      out.push(rest);
+      break;
+    }
+    // Keep the closing punctuation, drop the whitespace that followed it.
+    const cut = match.index + match[0].trimEnd().length;
+    out.push(rest.slice(0, cut).trim());
+    rest = rest.slice(match.index + match[0].length);
+  }
+  return out.filter(Boolean);
+}

package/src/plugins/builtin/earnings-calls/transcript-view.tsx

@@ -0,0 +1,334 @@
+import { useMemo, type RefObject } from "react";
+import { Spinner } from "../../../components";
+import { Tabs } from "../../../components/ui/tabs";
+import { colors } from "../../../theme/colors";
+import {
+  Box,
+  ScrollBox,
+  StyledText,
+  Text,
+  TextAttributes,
+  useUiCapabilities,
+  type ScrollBoxRenderable,
+} from "../../../ui";
+import { wrapTextLines } from "../../../utils/text-wrap";
+import type {
+  CloudEarningsTranscriptPayload,
+  CloudTranscriptTurnPayload,
+} from "../../../api-client";
+import { formatCallDate, formatDuration, formatSentiment, formatTimestamp } from "./format";
+import { splitFigures, splitSentences } from "./prose";
+
+export type ReaderTab = "summary" | "transcript" | "qa";
+
+export const READER_TABS: Array<{ label: string; value: ReaderTab }> = [
+  { label: "Summary", value: "summary" },
+  { label: "Transcript", value: "transcript" },
+  { label: "Q&A", value: "qa" },
+];
+
+/**
+ * Prose is capped at a comfortable measure. On a wide pane a full-width line
+ * is over two hundred characters, which the eye loses on the way back.
+ */
+const MAX_PROSE_WIDTH = 100;
+
+function speakerColor(turn: CloudTranscriptTurnPayload): string {
+  if (turn.speaker === "Operator") return colors.textDim;
+  if (turn.role === "Analyst") return colors.warning;
+  return colors.textBright;
+}
+
+/** Role and firm after the name; "Operator" is not repeated as its own role. */
+function turnDetail(turn: CloudTranscriptTurnPayload): string {
+  const role = turn.role && turn.role !== turn.speaker ? turn.role : null;
+  return [role, turn.company].filter(Boolean).join(", ");
+}
+
+const NATIVE_STRETCH_STYLE = { minWidth: 0 };
+const NATIVE_TEXT_STYLE = { display: "block" };
+
+/** Figures set in bold, the rest in the given colour. */
+function styledRuns(text: string, color: string, attributes = 0): StyledText {
+  return new StyledText(
+    splitFigures(text).map((run) => ({
+      text: run.text,
+      fg: run.figure ? colors.textBright : color,
+      attributes: run.figure ? attributes | TextAttributes.BOLD : attributes,
+    })),
+  );
+}
+
+/**
+ * A paragraph with figures in bold. The terminal renderer does not wrap on
+ * its own, so lines are pre-wrapped and styled one at a time; desktop
+ * chrome wraps the styled paragraph itself. `indent` is applied to every
+ * line after the first, for bullets.
+ */
+function Prose({
+  text,
+  width,
+  color,
+  nativePaneChrome,
+  prefix = "",
+}: {
+  text: string;
+  width: number;
+  color: string;
+  nativePaneChrome: boolean;
+  /** Put before the first line; later lines are indented by its width. */
+  prefix?: string;
+}) {
+  if (!text.trim()) return null;
+  if (nativePaneChrome) {
+    return (
+      <Box flexDirection="row" width="100%" style={NATIVE_STRETCH_STYLE}>
+        {prefix ? <Text fg={colors.textDim}>{prefix}</Text> : null}
+        <Text
+          wrapText
+          width="100%"
+          style={NATIVE_TEXT_STYLE}
+          content={styledRuns(text, color)}
+        />
+      </Box>
+    );
+  }
+  const indent = " ".repeat(prefix.length);
+  return wrapTextLines(text, Math.max(8, width - prefix.length)).map((line, index) => (
+    <Box key={index} height={1} flexDirection="row">
+      {prefix ? (
+        <Text fg={colors.textDim} flexShrink={0}>
+          {index === 0 ? prefix : indent}
+        </Text>
+      ) : null}
+      <Text content={styledRuns(line, color)} />
+    </Box>
+  ));
+}
+
+function SectionHeading({ title }: { title: string }) {
+  return (
+    <Box height={1} marginTop={1}>
+      <Text fg={colors.textDim} attributes={TextAttributes.BOLD}>
+        {title}
+      </Text>
+    </Box>
+  );
+}
+
+/** A summary section as one point per sentence. */
+function Section({
+  title,
+  body,
+  width,
+  nativePaneChrome,
+}: {
+  title: string;
+  body: string;
+  width: number;
+  nativePaneChrome: boolean;
+}) {
+  if (!body.trim()) return null;
+  return (
+    <Box flexDirection="column">
+      <SectionHeading title={title} />
+      {splitSentences(body).map((sentence, index) => (
+        <Prose
+          key={index}
+          text={sentence}
+          width={width}
+          color={colors.text}
+          nativePaneChrome={nativePaneChrome}
+          prefix="• "
+        />
+      ))}
+    </Box>
+  );
+}
+
+function TurnView({
+  turn,
+  width,
+  nativePaneChrome,
+}: {
+  turn: CloudTranscriptTurnPayload;
+  width: number;
+  nativePaneChrome: boolean;
+}) {
+  const detail = turnDetail(turn);
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      <Box height={1} flexDirection="row" gap={1} overflow="hidden">
+        <Text fg={colors.textDim}>{formatTimestamp(turn.startSeconds)}</Text>
+        <Text fg={speakerColor(turn)} attributes={TextAttributes.BOLD}>
+          {turn.speaker}
+        </Text>
+        {detail ? <Text fg={colors.textDim}>{detail}</Text> : null}
+      </Box>
+      <Prose text={turn.text} width={width} color={colors.text} nativePaneChrome={nativePaneChrome} />
+    </Box>
+  );
+}
+
+export function TranscriptView({
+  transcript,
+  loading,
+  error,
+  tab,
+  onTabChange,
+  tabsFocused,
+  query,
+  width,
+  scrollRef,
+}: {
+  transcript: CloudEarningsTranscriptPayload | null;
+  loading: boolean;
+  error: string | null;
+  tab: ReaderTab;
+  onTabChange: (tab: ReaderTab) => void;
+  /** Whether left/right should move between tabs. */
+  tabsFocused: boolean;
+  /** Free-text filter applied to the turns, for finding a topic in a long call. */
+  query?: string;
+  width: number;
+  /** Lets the owning pane drive keyboard scrolling. */
+  scrollRef?: RefObject<ScrollBoxRenderable | null>;
+}) {
+  const { nativePaneChrome } = useUiCapabilities();
+  const isNative = nativePaneChrome === true;
+
+  const turns = useMemo(() => {
+    const all = transcript?.turns ?? [];
+    const scoped = tab === "qa" ? all.filter((turn) => turn.isQa) : all;
+    const needle = (query ?? "").trim().toLowerCase();
+    if (!needle) return scoped;
+    return scoped.filter((turn) =>
+      `${turn.speaker} ${turn.company ?? ""} ${turn.text}`.toLowerCase().includes(needle),
+    );
+  }, [transcript, tab, query]);
+
+  if (loading && !transcript) {
+    return (
+      <Box flexGrow={1} alignItems="center" justifyContent="center">
+        <Spinner label="Loading transcript..." />
+      </Box>
+    );
+  }
+
+  if (error && !transcript) {
+    return (
+      <Box flexGrow={1} paddingX={1}>
+        <Text fg={colors.negative}>{error}</Text>
+      </Box>
+    );
+  }
+
+  if (!transcript) return null;
+
+  // The stack title already names ticker and period, so lead with metadata.
+  const meta = [
+    formatCallDate(transcript.callAt),
+    formatDuration(transcript.durationSeconds),
+    transcript.participants.length > 0 ? `${transcript.participants.length} speakers` : null,
+    transcript.sentiment !== null ? `sentiment ${formatSentiment(transcript.sentiment)}` : null,
+  ]
+    .filter(Boolean)
+    .join("  ·  ");
+
+  // One column of padding each side inside the scroll box.
+  const bodyWidth = Math.max(12, width - 2);
+  const proseWidth = Math.min(bodyWidth, MAX_PROSE_WIDTH);
+  const contentWidth = isNative ? "100%" : bodyWidth;
+  const contentStyle = isNative ? NATIVE_STRETCH_STYLE : undefined;
+  const hasQa = (transcript.turns ?? []).some((turn) => turn.isQa);
+
+  return (
+    <Box
+      flexDirection="column"
+      flexGrow={1}
+      flexShrink={1}
+      flexBasis={0}
+      minHeight={0}
+      overflow="hidden"
+    >
+      <Box height={1} flexShrink={0} paddingX={1} overflow="hidden">
+        <Tabs
+          tabs={READER_TABS.map((entry) => ({
+            label: entry.label,
+            value: entry.value,
+            disabled: entry.value === "qa" && !hasQa,
+          }))}
+          activeValue={tab}
+          onSelect={(value) => onTabChange(value as ReaderTab)}
+          compact
+          variant="bare"
+          focused={tabsFocused}
+        />
+      </Box>
+      <ScrollBox
+        ref={scrollRef}
+        flexGrow={1}
+        flexShrink={1}
+        flexBasis={0}
+        minHeight={0}
+        scrollY
+        focusable={false}
+        paddingX={1}
+      >
+        <Box flexDirection="column" width={contentWidth} style={contentStyle}>
+          {tab === "summary" ? (
+            <>
+              <Prose text={meta} width={proseWidth} color={colors.textDim} nativePaneChrome={isNative} />
+              <Section title="SUMMARY" body={transcript.summary ?? ""} width={proseWidth} nativePaneChrome={isNative} />
+              <Section title="WHAT STOOD OUT" body={transcript.notable ?? ""} width={proseWidth} nativePaneChrome={isNative} />
+              <Section title="ANALYSTS PRESSED ON" body={transcript.analystFocus ?? ""} width={proseWidth} nativePaneChrome={isNative} />
+              <Section title="GUIDANCE" body={transcript.guidance ?? ""} width={proseWidth} nativePaneChrome={isNative} />
+              <Section title="RISKS" body={transcript.riskFactors ?? ""} width={proseWidth} nativePaneChrome={isNative} />
+              {transcript.participants.length > 0 && (
+                <Box flexDirection="column">
+                  <SectionHeading title="PARTICIPANTS" />
+                  {transcript.participants.map((participant) => (
+                    <Prose
+                      key={participant.name}
+                      text={[participant.name, participant.role, participant.company]
+                        .filter(Boolean)
+                        .join("  ·  ")}
+                      width={proseWidth}
+                      color={colors.text}
+                      nativePaneChrome={isNative}
+                    />
+                  ))}
+                </Box>
+              )}
+            </>
+          ) : (
+            <>
+              {turns.map((turn, index) => (
+                <TurnView
+                  key={`${turn.startSeconds}-${index}`}
+                  turn={turn}
+                  width={proseWidth}
+                  nativePaneChrome={isNative}
+                />
+              ))}
+              {turns.length === 0 && (
+                <Box marginTop={1}>
+                  <Prose
+                    text={
+                      query?.trim()
+                        ? `Nothing matching "${query.trim()}" in this call.`
+                        : "No question and answer section in this call."
+                    }
+                    width={proseWidth}
+                    color={colors.textDim}
+                    nativePaneChrome={isNative}
+                  />
+                </Box>
+              )}
+            </>
+          )}
+        </Box>
+      </ScrollBox>
+    </Box>
+  );
+}

package/src/plugins/builtin/econ/detail-view.tsx

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, ScrollBox, Text, TextAttributes, type ScrollBoxRenderable } from "../../../ui";
 import { StaticChartSurface } from "../../../components";
-import { resolveChartPalette } from "../../../components/chart/core/renderer";
+import { resolveChartPalette } from "../../../components/chart/core/palette";
 import type { ProjectedChartPoint } from "../../../components/chart/core/data";
 import { colors } from "../../../theme/colors";
 import { apiClient, type CloudFredObservationPayload } from "../../../api-client";
@@ -263,7 +263,6 @@ export function EconDetailView({ event, width, height, focused }: EconDetailView
                 height={chartHeight}
                 mode="area"
                 colors={palette}
-                timeAxisDates={chartPoints.map((p) => p.date)}
                 showTimeAxis
                 timeAxisColor={colors.textDim}
                 yAxisLabel={units ? `Value (${units})` : "Value"}

package/src/plugins/builtin/econ/fred-series-map.ts

@@ -98,6 +98,21 @@ const FRED_CATALOG_SERIES: ReadonlyArray<{ seriesId: string; label: string }> =
   }));
 })();
 
+/**
+ * Macro series the catalog should offer that are not economic-calendar releases, so
+ * they have no natural home in SERIES_MAP above.
+ */
+const EXTRA_CATALOG_SERIES: ReadonlyArray<{ seriesId: string; label: string }> = [
+  { seriesId: "M2SL", label: "M2 Money Stock" },
+  { seriesId: "DFII10", label: "10Y TIPS Real Yield" },
+  { seriesId: "NCBEILQ027S", label: "Corporate Equities, Z.1" },
+  { seriesId: "TNWMVBSNNCB", label: "Corporate Net Worth, Z.1" },
+];
+
 export function listFredCatalogSeries(): ReadonlyArray<{ seriesId: string; label: string }> {
-  return FRED_CATALOG_SERIES;
+  const known = new Set(FRED_CATALOG_SERIES.map((entry) => entry.seriesId));
+  return [
+    ...FRED_CATALOG_SERIES,
+    ...EXTRA_CATALOG_SERIES.filter((entry) => !known.has(entry.seriesId)),
+  ];
 }

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

@@ -406,8 +406,9 @@ export const economicCalendarModule: PluginModule = {
     paneId: "econ-calendar",
     label: "Economic Calendar",
     description: "Upcoming economic events, releases, and indicators.",
+    // "econ" stays a keyword so the old ECON prefix still finds this pane.
     keywords: ["econ", "economic", "calendar", "events", "macro", "releases", "fed", "cpi", "gdp"],
-    shortcut: { prefix: "ECON" },
+    shortcut: { prefix: "ECO" },
   }],
   setup(ctx) {
     attachEconCalendarPersistence(ctx.persistence);

package/src/plugins/builtin/econ-statistics/cache.ts

@@ -0,0 +1,4 @@
+import { createSeriesCache } from "../shared/series-cache";
+
+/** Most of these print monthly, so a six-hour window is plenty. */
+export const statsCache = createSeriesCache("econ-statistics-series", 6 * 60 * 60 * 1000);

package/src/plugins/builtin/econ-statistics/client.ts

@@ -0,0 +1,92 @@
+import { apiClient } from "../../../api-client";
+import type { DatedObservation } from "../shared/series-cache";
+import { statsCache } from "./cache";
+import type { StatDef } from "./defs";
+import { STATS } from "./stats";
+import { applyTransform, type StatPoint } from "./transform";
+import { fitTrend, type TrendFit } from "./trend";
+
+export type StatSeriesLoader = (def: StatDef) => Promise<DatedObservation[]>;
+
+export interface StatBuild {
+  stat: StatDef;
+  points: StatPoint[];
+  trend: TrendFit;
+}
+
+export interface StatsBundle {
+  builds: StatBuild[];
+  errors: string[];
+  fetchedAt: number;
+}
+
+export type StatsCloudClient = Pick<typeof apiClient, "getCloudFredSeries">;
+
+export function createStatSeriesLoader(client: StatsCloudClient): StatSeriesLoader {
+  const cloudLoader: StatSeriesLoader = async (def) => {
+    const data = await client.getCloudFredSeries(def.seriesId, {
+      limit: def.limit,
+      sortOrder: "desc",
+    });
+    return data.observations;
+  };
+  return (def) => statsCache.load(def.seriesId, () => cloudLoader(def));
+}
+
+export const defaultStatLoader = createStatSeriesLoader(apiClient);
+
+function build(def: StatDef, observations: DatedObservation[]): StatBuild | null {
+  const scale = def.scale ?? 1;
+  const scaled = scale === 1
+    ? observations
+    : observations.map((entry) => ({
+      date: entry.date,
+      value: entry.value == null ? null : entry.value * scale,
+    }));
+  const points = applyTransform(scaled, def.transform);
+  if (points.length === 0) return null;
+  return { stat: def, points, trend: fitTrend(points) };
+}
+
+/** Builds whatever the on-disk cache can already answer, for an instant first paint. */
+export function getCachedStatsBundle(stats: readonly StatDef[] = STATS): StatsBundle | null {
+  const builds: StatBuild[] = [];
+  for (const def of stats) {
+    const cached = statsCache.get(def.seriesId, { allowExpired: true });
+    if (!cached) continue;
+    const entry = build(def, cached.observations);
+    if (entry) builds.push(entry);
+  }
+  return builds.length > 0 ? { builds, errors: [], fetchedAt: Date.now() } : null;
+}
+
+export async function loadStatsBundle(options?: {
+  loader?: StatSeriesLoader;
+  stats?: readonly StatDef[];
+}): Promise<StatsBundle> {
+  const loader = options?.loader ?? defaultStatLoader;
+  const stats = options?.stats ?? STATS;
+  const errors: string[] = [];
+
+  const settled = await Promise.all(stats.map(async (def) => {
+    try {
+      return { def, observations: await loader(def) };
+    } catch (error) {
+      errors.push(`${def.seriesId}: ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }));
+
+  const builds: StatBuild[] = [];
+  for (const entry of settled) {
+    if (!entry) continue;
+    const made = build(entry.def, entry.observations);
+    if (made) builds.push(made);
+    else errors.push(`${entry.def.seriesId}: no observations after transform`);
+  }
+
+  if (builds.length === 0) {
+    throw new Error(errors[0] ?? "Economic statistics unavailable");
+  }
+  return { builds, errors, fetchedAt: Date.now() };
+}

package/src/plugins/builtin/econ-statistics/defs.ts

@@ -0,0 +1,66 @@
+import { blendHex, colors } from "../../../theme/colors";
+import type { StatTransform } from "./transform";
+
+export type StatCategoryId =
+  | "inflation"
+  | "labor"
+  | "growth"
+  | "consumer"
+  | "housing"
+  | "rates"
+  | "trade";
+
+export const STAT_CATEGORIES: ReadonlyArray<{ id: StatCategoryId; label: string }> = [
+  { id: "inflation", label: "Inflation" },
+  { id: "labor", label: "Labor" },
+  { id: "growth", label: "Growth" },
+  { id: "consumer", label: "Consumer" },
+  { id: "housing", label: "Housing" },
+  { id: "rates", label: "Rates & Money" },
+  { id: "trade", label: "Trade & Costs" },
+];
+
+/**
+ * Whether a rising number is welcome. Unemployment climbing is bad, payrolls
+ * climbing is good, and an index level like CPI is neither on its own, so the
+ * table colours the change accordingly instead of pretending every rise is green.
+ */
+export type StatDirection = "higher-is-good" | "higher-is-bad" | "neutral";
+
+export interface StatDef {
+  id: string;
+  label: string;
+  /** Fits the table's INDICATOR column. */
+  shortLabel: string;
+  category: StatCategoryId;
+  seriesId: string;
+  transform: StatTransform;
+  /**
+   * Multiplier applied to raw observations before the transform, to bring a series
+   * into the unit it is quoted in. Percent changes are ratios, so scaling cannot
+   * affect them; it only matters for levels.
+   */
+  scale?: number;
+  direction: StatDirection;
+  /** Drives the chart axis and the cursor readout. */
+  axisUnit: "%" | "";
+  formatValue: (value: number) => string;
+  /** A level that means something: the Fed's target, zero for a spread. */
+  reference: { value: number; label: string } | null;
+  /** How old the newest print may get before the pane flags it stale. */
+  staleAfterMs: number;
+  note: string;
+  limit: number;
+}
+
+export function categoryLabel(id: StatCategoryId): string {
+  return STAT_CATEGORIES.find((entry) => entry.id === id)?.label ?? id;
+}
+
+/** Green when the move is welcome, red when it is not, plain when it is neither. */
+export function changeColor(direction: StatDirection, change: number | null): string {
+  if (change == null || !Number.isFinite(change) || change === 0) return colors.textMuted;
+  if (direction === "neutral") return colors.text;
+  const good = direction === "higher-is-good" ? change > 0 : change < 0;
+  return good ? colors.positive : blendHex(colors.negative, "#000000", 0.1);
+}