gloomberb 0.11.2 → 0.12.0

package/src/plugins/builtin/market-valuation/view.ts

@@ -0,0 +1,137 @@
+import { vintageLabel, type RatioPoint, type ValuationSeries } from "./align";
+import { meanRatio, projectChart, type ValuationChartProjection } from "./chart-projection";
+import {
+  RANGE_WINDOWS_MS,
+  classifyZone,
+  higherIsExpensive,
+  type IndicatorDef,
+  type ValuationRangeId,
+  type ZoneHit,
+} from "./defs";
+import { sigmaVsTrend, trendAt, type TrendFit } from "./trend";
+import { formatNumber } from "../../../utils/format";
+
+const MS_PER_DAY = 86_400_000;
+
+export interface Extreme {
+  ratio: number;
+  date: string;
+}
+
+export interface IndicatorBuild {
+  indicator: IndicatorDef;
+  series: ValuationSeries;
+  trend: TrendFit;
+}
+
+export interface ValuationBundle {
+  builds: IndicatorBuild[];
+  errors: string[];
+  fetchedAt: number;
+}
+
+export function formatSigma(sigma: number): string {
+  return `${sigma > 0 ? "+" : ""}${formatNumber(sigma, 1)}σ`;
+}
+
+export interface IndicatorViewModel {
+  indicator: IndicatorDef;
+  range: ValuationRangeId;
+  current: RatioPoint;
+  zone: ZoneHit;
+  /** Raw fit deviation, in the indicator's own direction. */
+  sigmaVsTrend: number;
+  /** Deviation restated so positive always means expensive. */
+  richSigma: number;
+  /** Share of history this market was cheaper than, so 100 is the richest ever. */
+  richPercentile: number;
+  trendNow: number;
+  mean: number;
+  vintageLabel: string | null;
+  ratioOneYearAgo: number | null;
+  allTimeHigh: Extreme;
+  allTimeLow: Extreme;
+  percentile: number;
+  chart: ValuationChartProjection;
+  asOf: string;
+  observationStale: boolean;
+}
+
+function parseDateMs(date: string): number {
+  return Date.parse(date);
+}
+
+export function sliceByRange(
+  points: readonly RatioPoint[],
+  range: ValuationRangeId,
+  nowMs: number = Date.parse(points.at(-1)!.date),
+): RatioPoint[] {
+  const window = RANGE_WINDOWS_MS[range];
+  if (window == null) return [...points];
+  const cutoff = nowMs - window;
+  const sliced = points.filter((p) => parseDateMs(p.date) >= cutoff);
+  return sliced.length >= 2 ? sliced : [...points];
+}
+
+function findExtreme(points: readonly RatioPoint[], pick: "high" | "low"): Extreme {
+  let best = points[0]!;
+  for (const p of points) {
+    if (pick === "high" ? p.ratio > best.ratio : p.ratio < best.ratio) best = p;
+  }
+  return { ratio: best.ratio, date: best.date };
+}
+
+function ratioOneYearAgo(points: readonly RatioPoint[], currentDate: string): number | null {
+  const cutoff = parseDateMs(currentDate) - 365 * MS_PER_DAY;
+  let found: RatioPoint | null = null;
+  for (const p of points) {
+    if (parseDateMs(p.date) <= cutoff) found = p;
+  }
+  return found?.ratio ?? null;
+}
+
+export function projectView(
+  build: IndicatorBuild,
+  range: ValuationRangeId,
+  opts: { nowMs?: number } = {},
+): IndicatorViewModel {
+  const { indicator, series, trend } = build;
+  const points = series.points;
+  const current = points[points.length - 1]!;
+  const nowMs = opts.nowMs ?? Date.now();
+  const visible = sliceByRange(points, range);
+  const mean = meanRatio(points);
+  const atOrBelow = points.filter((p) => p.ratio <= current.ratio).length;
+  const percentile = points.length === 0 ? 0 : (100 * atOrBelow) / points.length;
+  const sigma = sigmaVsTrend(trend, current.ratio, current.date);
+  const expensiveUp = higherIsExpensive(indicator);
+
+  return {
+    indicator,
+    range,
+    current,
+    zone: classifyZone(indicator, current.ratio),
+    sigmaVsTrend: sigma,
+    richSigma: expensiveUp ? sigma : -sigma,
+    richPercentile: expensiveUp ? percentile : 100 - percentile,
+    trendNow: trendAt(trend, current.date),
+    mean,
+    vintageLabel: indicator.input.kind === "ratio" && indicator.input.levels
+      ? vintageLabel(indicator.input.levels.denominatorLabel, series.vintageDate)
+      : null,
+    ratioOneYearAgo: ratioOneYearAgo(points, current.date),
+    allTimeHigh: findExtreme(points, "high"),
+    allTimeLow: findExtreme(points, "low"),
+    percentile,
+    chart: projectChart(indicator, visible, mean),
+    asOf: current.date,
+    observationStale: nowMs - parseDateMs(current.date) > indicator.staleAfterMs,
+  };
+}
+
+export function selectValuationViews(
+  bundle: ValuationBundle,
+  range: ValuationRangeId,
+): IndicatorViewModel[] {
+  return bundle.builds.map((build) => projectView(build, range));
+}

package/src/plugins/builtin/market-valuation/zone-scale/desktop.tsx

@@ -0,0 +1,123 @@
+import { createElement, type SVGProps } from "react";
+import { Box } from "../../../../ui";
+import { useThemeColors } from "../../../../theme/theme-context";
+import { zoneScaleGeometry, type ZoneScaleProps } from "./model";
+
+const VIEWBOX_WIDTH = 1000;
+const VIEWBOX_HEIGHT = 78;
+const BAR_TOP = 26;
+const BAR_HEIGHT = 14;
+const BAR_RADIUS = 7;
+const GAP = 3;
+const TICK_LABEL_INSET = 34;
+
+function SvgText(props: SVGProps<SVGTextElement>) {
+  return createElement("text", props);
+}
+
+export function DesktopZoneColorScale({ indicator, value, width, markerColor }: ZoneScaleProps) {
+  const colors = useThemeColors();
+  const geometry = zoneScaleGeometry(indicator, value, Math.max(48, width));
+  const markerX = geometry.markerFraction * VIEWBOX_WIDTH;
+  const barMiddle = BAR_TOP + BAR_HEIGHT / 2;
+
+  return (
+    <Box width={width} height={3} overflow="hidden">
+      <svg
+        viewBox={`0 0 ${VIEWBOX_WIDTH} ${VIEWBOX_HEIGHT}`}
+        width="100%"
+        height="100%"
+        preserveAspectRatio="none"
+        role="img"
+        aria-label={`${indicator.label} ${indicator.formatValue(value)} on the valuation scale`}
+        style={{ display: "block" }}
+      >
+        {geometry.bands.map((band, index) => {
+          const x = band.startFraction * VIEWBOX_WIDTH;
+          const barWidth = (band.endFraction - band.startFraction) * VIEWBOX_WIDTH - GAP;
+          const active = value >= band.from && value < band.to;
+          const first = index === 0;
+          const last = index === geometry.bands.length - 1;
+          return (
+            <rect
+              key={band.id}
+              x={x + (first ? 0 : GAP / 2)}
+              y={BAR_TOP}
+              width={Math.max(1, barWidth)}
+              height={BAR_HEIGHT}
+              rx={first || last ? BAR_RADIUS : 2}
+              fill={band.color}
+              opacity={active ? 1 : 0.4}
+            />
+          );
+        })}
+
+        {geometry.ticks.map((tick) => {
+          const x = tick.fraction * VIEWBOX_WIDTH;
+          return (
+            <g key={`tick:${tick.label}`}>
+              <line
+                x1={x}
+                y1={BAR_TOP + BAR_HEIGHT + 2}
+                x2={x}
+                y2={BAR_TOP + BAR_HEIGHT + 8}
+                stroke={colors.textDim}
+                strokeWidth="2"
+              />
+              <SvgText
+                // Half a label's width of inset, so the end ticks are not clipped.
+                x={Math.min(VIEWBOX_WIDTH - TICK_LABEL_INSET, Math.max(TICK_LABEL_INSET, x))}
+                y={VIEWBOX_HEIGHT - 4}
+                fill={colors.textDim}
+                textAnchor="middle"
+                fontFamily="inherit"
+                fontSize="15"
+              >
+                {tick.label}
+              </SvgText>
+            </g>
+          );
+        })}
+
+        {geometry.underLabel ? (
+          <SvgText x={0} y={16} fill={colors.textDim} textAnchor="start" fontFamily="inherit" fontSize="15">
+            {geometry.underLabel}
+          </SvgText>
+        ) : null}
+        {geometry.fairLabel ? (
+          <SvgText
+            x={VIEWBOX_WIDTH / 2}
+            y={16}
+            fill={colors.textDim}
+            textAnchor="middle"
+            fontFamily="inherit"
+            fontSize="15"
+          >
+            {geometry.fairLabel}
+          </SvgText>
+        ) : null}
+        {geometry.overLabel ? (
+          <SvgText
+            x={VIEWBOX_WIDTH}
+            y={16}
+            fill={colors.textDim}
+            textAnchor="end"
+            fontFamily="inherit"
+            fontSize="15"
+          >
+            {geometry.overLabel}
+          </SvgText>
+        ) : null}
+
+        <circle
+          cx={Math.min(VIEWBOX_WIDTH - 6, Math.max(6, markerX))}
+          cy={barMiddle}
+          r="9"
+          fill={markerColor}
+          stroke={colors.bg}
+          strokeWidth="3"
+        />
+      </svg>
+    </Box>
+  );
+}

package/src/plugins/builtin/market-valuation/zone-scale/index.tsx

@@ -0,0 +1,12 @@
+import { useUiHost } from "../../../../ui";
+import { DesktopZoneColorScale } from "./desktop";
+import type { ZoneScaleProps } from "./model";
+import { TerminalZoneColorScale } from "./terminal";
+
+export type { ZoneScaleProps } from "./model";
+
+export function ZoneColorScale(props: ZoneScaleProps) {
+  return useUiHost().kind === "desktop-web"
+    ? <DesktopZoneColorScale {...props} />
+    : <TerminalZoneColorScale {...props} />;
+}

package/src/plugins/builtin/market-valuation/zone-scale/model.ts

@@ -0,0 +1,60 @@
+import {
+  zoneScaleBands,
+  zoneScaleFraction,
+  type IndicatorDef,
+  type ZoneScaleBand,
+} from "../defs";
+
+export interface ZoneScaleProps {
+  indicator: IndicatorDef;
+  value: number;
+  width: number;
+  markerColor: string;
+}
+
+export interface ZoneScaleTick {
+  label: string;
+  fraction: number;
+}
+
+export interface ZoneScaleGeometry {
+  bands: Array<ZoneScaleBand & { from: number; to: number; startFraction: number; endFraction: number }>;
+  markerFraction: number;
+  ticks: ZoneScaleTick[];
+  underLabel: string;
+  overLabel: string;
+  fairLabel: string;
+}
+
+/** Captions and ticks thin out as the pane narrows so the bar never overprints itself. */
+export function zoneScaleGeometry(
+  indicator: IndicatorDef,
+  value: number,
+  width: number,
+): ZoneScaleGeometry {
+  const raw = zoneScaleBands(indicator);
+  const count = raw.length;
+  const bands = raw.map((band, index) => ({
+    ...band,
+    startFraction: index / count,
+    endFraction: (index + 1) / count,
+  }));
+
+  const allTicks = indicator.zoneScale.ticks;
+  const keep = width >= 40
+    ? allTicks
+    : allTicks.filter((tick, index) =>
+      index === 0 || index === allTicks.length - 1 || tick === indicator.reference?.value);
+
+  return {
+    bands,
+    markerFraction: zoneScaleFraction(indicator, value),
+    ticks: keep.map((tick) => ({
+      label: indicator.formatValue(tick),
+      fraction: zoneScaleFraction(indicator, tick),
+    })),
+    underLabel: width >= 48 ? "undervalued" : width >= 28 ? "under" : "",
+    overLabel: width >= 48 ? "overvalued" : width >= 28 ? "over" : "",
+    fairLabel: width >= 64 ? "fair" : "",
+  };
+}

package/src/plugins/builtin/market-valuation/zone-scale/terminal.tsx

@@ -0,0 +1,94 @@
+import { Box, Text } from "../../../../ui";
+import { colors } from "../../../../theme/colors";
+import { zoneScaleColumnValue } from "../defs";
+import { zoneScaleGeometry, type ZoneScaleProps } from "./model";
+
+interface Cell {
+  char: string;
+  color: string;
+}
+
+function chunkRow(row: readonly Cell[]): Array<{ text: string; color: string }> {
+  const chunks: Array<{ text: string; color: string }> = [];
+  for (const cell of row) {
+    const last = chunks[chunks.length - 1];
+    if (last && last.color === cell.color) last.text += cell.char;
+    else chunks.push({ text: cell.char, color: cell.color });
+  }
+  return chunks;
+}
+
+function blankRow(width: number): Cell[] {
+  return Array.from({ length: width }, () => ({ char: " ", color: colors.textDim }));
+}
+
+function placeText(row: Cell[], label: string, start: number, color: string): void {
+  for (let index = 0; index < label.length; index += 1) {
+    const column = start + index;
+    if (column < 0 || column >= row.length) continue;
+    row[column] = { char: label[index]!, color };
+  }
+}
+
+export function TerminalZoneColorScale({ indicator, value, width, markerColor }: ZoneScaleProps) {
+  const scaleWidth = Math.max(12, width);
+  const geometry = zoneScaleGeometry(indicator, value, scaleWidth);
+  const marker = Math.round(geometry.markerFraction * (scaleWidth - 1));
+
+  const bar: Cell[] = [];
+  for (let column = 0; column < scaleWidth; column += 1) {
+    const columnValue = zoneScaleColumnValue(indicator, column, scaleWidth);
+    const band = geometry.bands.find((entry) => columnValue >= entry.from && columnValue < entry.to)
+      ?? geometry.bands[geometry.bands.length - 1]!;
+    bar.push({
+      char: column === marker ? "●" : "━",
+      color: column === marker ? markerColor : band.color,
+    });
+  }
+
+  const captions = blankRow(scaleWidth);
+  if (geometry.underLabel) placeText(captions, geometry.underLabel, 0, colors.textDim);
+  if (geometry.overLabel) {
+    placeText(captions, geometry.overLabel, scaleWidth - geometry.overLabel.length, colors.textDim);
+  }
+  const fairBand = geometry.bands.find((band) => band.id === "fair");
+  if (geometry.fairLabel && fairBand) {
+    const center = Math.round(
+      ((fairBand.startFraction + fairBand.endFraction) / 2) * (scaleWidth - 1),
+    );
+    const start = center - Math.floor((geometry.fairLabel.length - 1) / 2);
+    const overStart = scaleWidth - geometry.overLabel.length;
+    if (start >= geometry.underLabel.length + 1 && start + geometry.fairLabel.length <= overStart - 1) {
+      placeText(captions, geometry.fairLabel, start, colors.textDim);
+    }
+  }
+
+  const ticks = blankRow(scaleWidth);
+  for (const tick of geometry.ticks) {
+    const center = Math.round(tick.fraction * (scaleWidth - 1));
+    const start = Math.max(
+      0,
+      Math.min(scaleWidth - tick.label.length, center - Math.floor((tick.label.length - 1) / 2)),
+    );
+    const isReference = indicator.reference != null
+      && tick.label === indicator.formatValue(indicator.reference.value);
+    placeText(ticks, tick.label, start, isReference ? colors.textMuted : colors.textDim);
+  }
+
+  const rows: Array<{ id: string; cells: Cell[] }> = [];
+  if (geometry.underLabel || geometry.overLabel) rows.push({ id: "caption", cells: captions });
+  rows.push({ id: "bar", cells: bar });
+  rows.push({ id: "tick", cells: ticks });
+
+  return (
+    <Box flexDirection="column" width={scaleWidth} gap={0}>
+      {rows.map((row) => (
+        <Box key={row.id} flexDirection="row" height={1} overflow="hidden">
+          {chunkRow(row.cells).map((chunk, index) => (
+            <Text key={`${row.id}:${index}`} fg={chunk.color}>{chunk.text}</Text>
+          ))}
+        </Box>
+      ))}
+    </Box>
+  );
+}

package/src/plugins/builtin/news/wire/breaking/filters.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+import type { MarketNewsItem } from "../../../../../types/news-source";
+import {
+  isSectorMuted,
+  parseBreakingScope,
+  parseMutedSectors,
+  selectNotifiableArticles,
+} from "./filters";
+
+function article(overrides: Partial<MarketNewsItem> = {}): MarketNewsItem {
+  return {
+    id: "1",
+    title: "Headline",
+    url: "https://example.com/1",
+    source: "Reuters",
+    publishedAt: new Date("2026-09-01T12:00:00Z"),
+    topic: "general",
+    topics: [],
+    sectors: [],
+    categories: [],
+    tickers: [],
+    scores: { importance: 80, urgency: 80, marketImpact: 80, novelty: 50, confidence: 90 },
+    isBreaking: true,
+    isDeveloping: false,
+    importance: 80,
+    ...overrides,
+  };
+}
+
+const watched = new Set(["AAPL", "MSFT"]);
+
+describe("breaking notification scope", () => {
+  const macro = article({ id: "macro", tickers: [] });
+  const held = article({ id: "held", tickers: ["AAPL"] });
+  const unrelated = article({ id: "unrelated", tickers: ["XOM"] });
+  const all = [macro, held, unrelated];
+
+  const idsFor = (scope: string) =>
+    selectNotifiableArticles(all, {
+      scope: parseBreakingScope(scope),
+      mutedSectors: new Set(),
+      watchedSymbols: watched,
+    }).map((item) => item.id);
+
+  test("watchlist-macro keeps tracked tickers and market-wide stories", () => {
+    expect(idsFor("watchlist-macro")).toEqual(["macro", "held"]);
+  });
+
+  test("watchlist drops market-wide stories", () => {
+    expect(idsFor("watchlist")).toEqual(["held"]);
+  });
+
+  test("macro drops every ticker-linked story", () => {
+    expect(idsFor("macro")).toEqual(["macro"]);
+  });
+
+  test("all keeps everything", () => {
+    expect(idsFor("all")).toEqual(["macro", "held", "unrelated"]);
+  });
+
+  test("unknown or missing scope falls back to watchlist-macro", () => {
+    expect(parseBreakingScope(undefined)).toBe("watchlist-macro");
+    expect(parseBreakingScope("nonsense")).toBe("watchlist-macro");
+  });
+});
+
+describe("muted sectors", () => {
+  const muted = new Set(["health_care"]);
+
+  test("mutes a story confined to a muted sector", () => {
+    expect(isSectorMuted(article({ sectors: ["health_care"] }), muted)).toBe(true);
+  });
+
+  test("keeps a story that also spans an unmuted sector", () => {
+    expect(isSectorMuted(article({ sectors: ["health_care", "energy"] }), muted)).toBe(false);
+  });
+
+  test("keeps stories with no sector attribution", () => {
+    expect(isSectorMuted(article({ sectors: [] }), muted)).toBe(false);
+  });
+
+  test("ignores malformed stored values", () => {
+    expect(parseMutedSectors(undefined).size).toBe(0);
+    expect(parseMutedSectors(["energy", 3, ""]).has("energy")).toBe(true);
+    expect(parseMutedSectors(["energy", 3, ""]).size).toBe(1);
+  });
+});
+
+describe("scope and mute combined", () => {
+  test("a muted sector suppresses an otherwise in-scope watchlist story", () => {
+    const pharma = article({ id: "pharma", tickers: ["AAPL"], sectors: ["health_care"] });
+    const kept = selectNotifiableArticles([pharma], {
+      scope: "watchlist-macro",
+      mutedSectors: new Set(["health_care"]),
+      watchedSymbols: watched,
+    });
+    expect(kept).toEqual([]);
+  });
+});

package/src/plugins/builtin/news/wire/breaking/filters.ts

@@ -0,0 +1,110 @@
+import type { MarketNewsItem } from "../../../../../types/news-source";
+import { SECTOR_NEWS_SECTORS, sectorNewsLabel } from "../news/query-presets";
+
+export const BREAKING_NEWS_NOTIFICATIONS_ENABLED_KEY = "breakingNewsNotificationsEnabled";
+export const BREAKING_NEWS_SCOPE_KEY = "breakingNewsScope";
+export const BREAKING_NEWS_MUTED_SECTORS_KEY = "breakingNewsMutedSectors";
+
+export const BREAKING_SCOPES = [
+  "watchlist-macro",
+  "watchlist",
+  "macro",
+  "all",
+] as const;
+
+export type BreakingScope = (typeof BREAKING_SCOPES)[number];
+
+export const DEFAULT_BREAKING_SCOPE: BreakingScope = "watchlist-macro";
+
+export const BREAKING_SCOPE_OPTIONS = [
+  {
+    value: "watchlist-macro",
+    label: "Watchlist + macro",
+    description: "Stories about tickers you track, plus market-wide events.",
+  },
+  {
+    value: "watchlist",
+    label: "Watchlist only",
+    description: "Only stories linked to a ticker you watch or hold.",
+  },
+  {
+    value: "macro",
+    label: "Macro only",
+    description: "Only market-wide events with no single ticker.",
+  },
+  { value: "all", label: "Everything", description: "Every breaking story." },
+];
+
+export const BREAKING_MUTED_SECTOR_OPTIONS = SECTOR_NEWS_SECTORS.map((sector) => ({
+  value: sector,
+  label: sectorNewsLabel(sector),
+}));
+
+export function parseBreakingScope(value: unknown): BreakingScope {
+  return BREAKING_SCOPES.includes(value as BreakingScope)
+    ? (value as BreakingScope)
+    : DEFAULT_BREAKING_SCOPE;
+}
+
+export function parseMutedSectors(value: unknown): Set<string> {
+  if (!Array.isArray(value)) return new Set();
+  return new Set(
+    value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0),
+  );
+}
+
+/**
+ * A story with no ticker links is market-wide: policy, geopolitics, or market
+ * structure. The server never attributes those to a symbol, so absence of
+ * tickers is the signal.
+ */
+export function isMacroArticle(article: MarketNewsItem): boolean {
+  return article.tickers.length === 0;
+}
+
+export function matchesWatchlist(
+  article: MarketNewsItem,
+  watchedSymbols: ReadonlySet<string>,
+): boolean {
+  return article.tickers.some((ticker) => watchedSymbols.has(ticker.toUpperCase()));
+}
+
+export function matchesScope(
+  article: MarketNewsItem,
+  scope: BreakingScope,
+  watchedSymbols: ReadonlySet<string>,
+): boolean {
+  if (scope === "all") return true;
+  if (scope === "macro") return isMacroArticle(article);
+  if (scope === "watchlist") return matchesWatchlist(article, watchedSymbols);
+  return isMacroArticle(article) || matchesWatchlist(article, watchedSymbols);
+}
+
+/**
+ * Muted only when every sector is muted. A story spanning a muted and an
+ * unmuted sector still matters, so partial overlap is deliberately kept.
+ */
+export function isSectorMuted(
+  article: MarketNewsItem,
+  mutedSectors: ReadonlySet<string>,
+): boolean {
+  if (mutedSectors.size === 0 || article.sectors.length === 0) return false;
+  return article.sectors.every((sector) => mutedSectors.has(sector));
+}
+
+export interface BreakingNotificationFilter {
+  scope: BreakingScope;
+  mutedSectors: ReadonlySet<string>;
+  watchedSymbols: ReadonlySet<string>;
+}
+
+export function selectNotifiableArticles(
+  articles: MarketNewsItem[],
+  filter: BreakingNotificationFilter,
+): MarketNewsItem[] {
+  return articles.filter(
+    (article) =>
+      matchesScope(article, filter.scope, filter.watchedSymbols) &&
+      !isSectorMuted(article, filter.mutedSectors),
+  );
+}