gloomberb 0.15.2 → 0.15.3

package/src/plugins/builtin/fear-greed/data.ts

@@ -0,0 +1,376 @@
+import type { ProjectedChartPoint } from "../../../components";
+import { httpFetch, type HttpFetchTransport } from "../../../utils/http-transport";
+
+const CNN_FEAR_GREED_GRAPH_URL = "https://production.dataviz.cnn.io/index/fearandgreed/graphdata";
+const CNN_REFERER = "https://www.cnn.com/markets/fear-and-greed";
+const CNN_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+
+export type FearGreedRating = "extreme fear" | "fear" | "neutral" | "greed" | "extreme greed";
+
+type CnnGraphKey =
+  | "fear_and_greed"
+  | "fear_and_greed_historical"
+  | "market_momentum_sp500"
+  | "market_momentum_sp125"
+  | "stock_price_strength"
+  | "stock_price_breadth"
+  | "put_call_options"
+  | "market_volatility_vix"
+  | "market_volatility_vix_50"
+  | "safe_haven_demand"
+  | "junk_bond_demand";
+
+interface CnnPoint {
+  x?: unknown;
+  y?: unknown;
+  rating?: unknown;
+}
+
+interface CnnSeries {
+  timestamp?: unknown;
+  score?: unknown;
+  rating?: unknown;
+  previous_close?: unknown;
+  previous_1_week?: unknown;
+  previous_1_month?: unknown;
+  previous_1_year?: unknown;
+  data?: unknown;
+}
+
+export type CnnFearGreedGraphData = Partial<Record<CnnGraphKey, CnnSeries>>;
+
+interface NormalizedRawPoint {
+  x: number;
+  y: number;
+  rating: FearGreedRating | null;
+}
+
+interface FearGreedOverall {
+  score: number;
+  rating: FearGreedRating;
+  updatedAt: Date | null;
+  previousClose: number | null;
+  previousWeek: number | null;
+  previousMonth: number | null;
+  previousYear: number | null;
+  history: ProjectedChartPoint[];
+}
+
+export type FearGreedValueFormat = "score" | "number" | "percent" | "ratio";
+
+interface FearGreedIndicatorDefinition {
+  id: string;
+  title: string;
+  subtitle: string;
+  primaryKey: CnnGraphKey;
+  primaryLabel: string;
+  secondaryKey?: CnnGraphKey;
+  secondaryLabel?: string;
+  valueFormat: FearGreedValueFormat;
+}
+
+/** A secondary reading aligned to the primary series by observation index. */
+interface OverlayPoint {
+  index: number;
+  value: number;
+}
+
+export interface FearGreedIndicator {
+  definition: FearGreedIndicatorDefinition;
+  score: number | null;
+  rating: FearGreedRating;
+  updatedAt: Date | null;
+  points: ProjectedChartPoint[];
+  secondaryPoints: OverlayPoint[];
+  latestValue: number | null;
+  latestSecondaryValue: number | null;
+}
+
+export interface FearGreedData {
+  overall: FearGreedOverall;
+  indicators: FearGreedIndicator[];
+}
+
+const FEAR_GREED_INDICATORS: FearGreedIndicatorDefinition[] = [
+  {
+    id: "market-momentum",
+    title: "Market Momentum",
+    subtitle: "S&P 500 and its 125-day moving average",
+    primaryKey: "market_momentum_sp500",
+    primaryLabel: "S&P 500",
+    secondaryKey: "market_momentum_sp125",
+    secondaryLabel: "125-day moving average",
+    valueFormat: "number",
+  },
+  {
+    id: "stock-price-strength",
+    title: "Stock Price Strength",
+    subtitle: "Net new 52-week highs and lows on the NYSE",
+    primaryKey: "stock_price_strength",
+    primaryLabel: "Net highs/lows",
+    valueFormat: "percent",
+  },
+  {
+    id: "stock-price-breadth",
+    title: "Stock Price Breadth",
+    subtitle: "McClellan Volume Summation Index",
+    primaryKey: "stock_price_breadth",
+    primaryLabel: "McClellan index",
+    valueFormat: "number",
+  },
+  {
+    id: "put-call-options",
+    title: "Put and Call Options",
+    subtitle: "5-day average put/call ratio",
+    primaryKey: "put_call_options",
+    primaryLabel: "Put/call ratio",
+    valueFormat: "ratio",
+  },
+  {
+    id: "market-volatility",
+    title: "Market Volatility",
+    subtitle: "VIX and its 50-day moving average",
+    primaryKey: "market_volatility_vix",
+    primaryLabel: "VIX",
+    secondaryKey: "market_volatility_vix_50",
+    secondaryLabel: "50-day moving average",
+    valueFormat: "number",
+  },
+  {
+    id: "safe-haven-demand",
+    title: "Safe Haven Demand",
+    subtitle: "Difference in 20-day stock and bond returns",
+    primaryKey: "safe_haven_demand",
+    primaryLabel: "Stocks vs. bonds",
+    valueFormat: "percent",
+  },
+  {
+    id: "junk-bond-demand",
+    title: "Junk Bond Demand",
+    subtitle: "Yield spread: junk bonds vs. investment grade",
+    primaryKey: "junk_bond_demand",
+    primaryLabel: "Yield spread",
+    valueFormat: "percent",
+  },
+];
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function finiteNumber(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value;
+}
+
+function normalizeRating(value: unknown): FearGreedRating | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  switch (normalized) {
+    case "extreme fear":
+    case "fear":
+    case "neutral":
+    case "greed":
+    case "extreme greed":
+      return normalized;
+    default:
+      return null;
+  }
+}
+
+function fallbackRatingForScore(score: number | null): FearGreedRating {
+  if (score == null) return "neutral";
+  if (score < 25) return "extreme fear";
+  if (score < 45) return "fear";
+  if (score <= 55) return "neutral";
+  if (score <= 75) return "greed";
+  return "extreme greed";
+}
+
+function parseTimestamp(value: unknown): Date | null {
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  }
+  const millis = finiteNumber(value);
+  if (millis == null) return null;
+  const parsed = new Date(millis);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+
+function normalizeRawPoints(series: CnnSeries | undefined): NormalizedRawPoint[] {
+  if (!series || !Array.isArray(series.data)) return [];
+  const points: NormalizedRawPoint[] = [];
+  for (const item of series.data) {
+    if (!isObject(item)) continue;
+    const point = item as CnnPoint;
+    const x = finiteNumber(point.x);
+    const y = finiteNumber(point.y);
+    if (x == null || y == null) continue;
+    points.push({ x, y, rating: normalizeRating(point.rating) });
+  }
+  return points.sort((left, right) => left.x - right.x);
+}
+
+function toProjectedPoints(points: NormalizedRawPoint[]): ProjectedChartPoint[] {
+  return points.map((point) => ({
+    date: new Date(point.x),
+    open: point.y,
+    high: point.y,
+    low: point.y,
+    close: point.y,
+    volume: 0,
+  }));
+}
+
+function toSecondaryOverlay(primaryPoints: NormalizedRawPoint[], secondaryPoints: NormalizedRawPoint[]): OverlayPoint[] {
+  const indexByTimestamp = new Map(primaryPoints.map((point, index) => [point.x, index] as const));
+  const overlay: OverlayPoint[] = [];
+  for (let index = 0; index < secondaryPoints.length; index += 1) {
+    const point = secondaryPoints[index]!;
+    const matchedIndex = indexByTimestamp.get(point.x) ?? (index < primaryPoints.length ? index : null);
+    if (matchedIndex == null) continue;
+    overlay.push({ index: matchedIndex, value: point.y });
+  }
+  return overlay;
+}
+
+function latestValue(points: NormalizedRawPoint[]): number | null {
+  return points.length > 0 ? points[points.length - 1]!.y : null;
+}
+
+function latestRating(series: CnnSeries | undefined, points: NormalizedRawPoint[], score: number | null): FearGreedRating {
+  return normalizeRating(series?.rating)
+    ?? (points.length > 0 ? points[points.length - 1]!.rating : null)
+    ?? fallbackRatingForScore(score);
+}
+
+function latestTimestamp(series: CnnSeries | undefined, points: NormalizedRawPoint[]): Date | null {
+  return parseTimestamp(series?.timestamp)
+    ?? (points.length > 0 ? new Date(points[points.length - 1]!.x) : null);
+}
+
+export function normalizeFearGreedData(
+  charts: CnnFearGreedGraphData,
+  latest: CnnFearGreedGraphData = charts,
+): FearGreedData {
+  const latestOverallSeries = latest.fear_and_greed ?? charts.fear_and_greed;
+  const historySeries = charts.fear_and_greed_historical ?? latest.fear_and_greed_historical;
+  const historyRawPoints = normalizeRawPoints(historySeries);
+  const latestScore = finiteNumber(latestOverallSeries?.score)
+    ?? finiteNumber(historySeries?.score)
+    ?? latestValue(historyRawPoints);
+
+  if (latestScore == null) {
+    throw new Error("CNN Fear & Greed response did not include an index score");
+  }
+
+  const overall: FearGreedOverall = {
+    score: latestScore,
+    rating: normalizeRating(latestOverallSeries?.rating) ?? fallbackRatingForScore(latestScore),
+    updatedAt: parseTimestamp(latestOverallSeries?.timestamp) ?? latestTimestamp(historySeries, historyRawPoints),
+    previousClose: finiteNumber(latestOverallSeries?.previous_close),
+    previousWeek: finiteNumber(latestOverallSeries?.previous_1_week),
+    previousMonth: finiteNumber(latestOverallSeries?.previous_1_month),
+    previousYear: finiteNumber(latestOverallSeries?.previous_1_year),
+    history: toProjectedPoints(historyRawPoints),
+  };
+
+  const indicators = FEAR_GREED_INDICATORS.flatMap((definition): FearGreedIndicator[] => {
+    const series = charts[definition.primaryKey] ?? latest[definition.primaryKey];
+    const primaryPoints = normalizeRawPoints(series);
+    if (primaryPoints.length === 0) return [];
+
+    const secondarySeries = definition.secondaryKey
+      ? (charts[definition.secondaryKey] ?? latest[definition.secondaryKey])
+      : undefined;
+    const secondaryRawPoints = normalizeRawPoints(secondarySeries);
+    const score = finiteNumber(series?.score);
+
+    return [{
+      definition,
+      score,
+      rating: latestRating(series, primaryPoints, score),
+      updatedAt: latestTimestamp(series, primaryPoints),
+      points: toProjectedPoints(primaryPoints),
+      secondaryPoints: toSecondaryOverlay(primaryPoints, secondaryRawPoints),
+      latestValue: latestValue(primaryPoints),
+      latestSecondaryValue: latestValue(secondaryRawPoints),
+    }];
+  });
+
+  return { overall, indicators };
+}
+
+function formatLocalDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * CNN serves this endpoint only to something that looks like its own page, so
+ * the referer and user agent are not optional.
+ *
+ * They used to be dropped in a DOM runtime, where a browser refuses to let
+ * script set either. That is no longer the runtime making the request: every
+ * call goes through `httpFetch`, which hands it to the desktop's Bun process or
+ * to the hosted app's worker proxy, and both send these as real headers.
+ */
+function cnnFetchHeaders(): HeadersInit {
+  return {
+    Accept: "application/json,text/plain,*/*",
+    "User-Agent": CNN_USER_AGENT,
+    Referer: CNN_REFERER,
+  };
+}
+
+async function fetchCnnGraphData(url: string, fetcher: HttpFetchTransport): Promise<CnnFearGreedGraphData> {
+  const response = await fetcher(url, { headers: cnnFetchHeaders() });
+  const body = await response.text();
+  if (!response.ok) {
+    throw new Error(`CNN Fear & Greed request failed (${response.status}): ${body.slice(0, 120)}`);
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw new Error(`CNN Fear & Greed returned non-JSON data: ${body.slice(0, 120)}`);
+  }
+
+  if (!isObject(parsed)) {
+    throw new Error("CNN Fear & Greed response was not an object");
+  }
+
+  return parsed as CnnFearGreedGraphData;
+}
+
+export async function fetchFearGreedData(options: {
+  date?: Date;
+  fetcher?: HttpFetchTransport;
+} = {}): Promise<FearGreedData> {
+  const fetcher = options.fetcher ?? httpFetch;
+  const date = options.date ?? new Date();
+  const latestUrl = `${CNN_FEAR_GREED_GRAPH_URL}/${formatLocalDate(date)}`;
+
+  const [chartsResult, latestResult] = await Promise.allSettled([
+    fetchCnnGraphData(CNN_FEAR_GREED_GRAPH_URL, fetcher),
+    fetchCnnGraphData(latestUrl, fetcher),
+  ]);
+
+  const charts = chartsResult.status === "fulfilled" ? chartsResult.value : null;
+  const latest = latestResult.status === "fulfilled" ? latestResult.value : null;
+
+  if (!charts && !latest) {
+    const reason = chartsResult.status === "rejected"
+      ? chartsResult.reason
+      : latestResult.status === "rejected"
+        ? latestResult.reason
+        : "CNN Fear & Greed returned no data";
+    throw reason instanceof Error ? reason : new Error(String(reason));
+  }
+
+  return normalizeFearGreedData(charts ?? latest!, latest ?? charts ?? undefined);
+}

package/src/plugins/builtin/fear-greed/format.ts

@@ -0,0 +1,87 @@
+import type { SpeedometerSegment } from "../../../components";
+import { colors } from "../../../theme/colors";
+import { formatNumber } from "../../../utils/format";
+import type {
+  FearGreedRating,
+  FearGreedValueFormat,
+} from "./data";
+
+export const FEAR_GREED_GAUGE_SEGMENTS: SpeedometerSegment[] = [
+  { from: 0, to: 24.999, label: "EXTREME FEAR", color: colors.negative },
+  { from: 25, to: 44.999, label: "FEAR", color: colors.warning },
+  { from: 45, to: 55, label: "NEUTRAL", color: colors.neutral },
+  { from: 55.001, to: 75, label: "GREED", color: colors.positive },
+  { from: 75.001, to: 100, label: "EXTREME GREED", color: colors.positive },
+];
+
+export function ratingLabel(rating: FearGreedRating): string {
+  return rating.toUpperCase();
+}
+
+export function ratingColor(rating: FearGreedRating): string {
+  switch (rating) {
+    case "extreme fear":
+      return colors.negative;
+    case "fear":
+      return colors.warning;
+    case "neutral":
+      return colors.neutral;
+    case "greed":
+    case "extreme greed":
+      return colors.positive;
+  }
+}
+
+export function ratingTrend(rating: FearGreedRating): "positive" | "negative" | "neutral" {
+  switch (rating) {
+    case "extreme fear":
+    case "fear":
+      return "negative";
+    case "neutral":
+      return "neutral";
+    case "greed":
+    case "extreme greed":
+      return "positive";
+  }
+}
+
+export function formatScore(score: number | null | undefined): string {
+  if (score == null || Number.isNaN(score)) return "--";
+  return String(Math.round(score));
+}
+
+export function formatIndicatorValue(value: number | null | undefined, format: FearGreedValueFormat): string {
+  if (value == null || Number.isNaN(value)) return "--";
+  switch (format) {
+    case "score":
+      return formatScore(value);
+    case "percent":
+      return `${formatNumber(value, 2)}%`;
+    case "ratio":
+      return value.toFixed(2);
+    case "number": {
+      const abs = Math.abs(value);
+      if (abs >= 1000) return formatNumber(value, 0);
+      if (abs >= 100) return formatNumber(value, 1);
+      return formatNumber(value, 2);
+    }
+  }
+}
+
+export function formatAxisValue(format: FearGreedValueFormat): (value: number) => string {
+  return (value) => formatIndicatorValue(value, format);
+}
+
+export function formatUpdatedAt(date: Date | null): string {
+  if (!date) return "Last updated --";
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/New_York",
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+  }).formatToParts(date);
+  const part = (type: Intl.DateTimeFormatPartTypes) => parts.find((entry) => entry.type === type)?.value ?? "";
+  return `Last updated ${part("month")} ${part("day")} at ${part("hour")}:${part("minute")} ${part("dayPeriod")} ET`;
+}

package/src/plugins/builtin/fear-greed/headless.ts

@@ -0,0 +1,85 @@
+import type {
+  HeadlessBundleResult,
+  HeadlessPaneDefinition,
+  HeadlessPaneLoadArgs,
+} from "../../../types/plugin";
+import { httpFetch } from "../../../utils/http-transport";
+import { loadFearGreed, type FearGreedLoadResult } from "./cache";
+import { fetchFearGreedData, type FearGreedData } from "./data";
+import { formatIndicatorValue, formatScore, ratingLabel } from "./format";
+
+export function projectFearGreedHeadless(data: FearGreedData): HeadlessBundleResult {
+  return {
+    sections: [
+      {
+        title: "Fear & Greed Index",
+        entries: [
+          { label: "Score", value: data.overall.score, formatted: formatScore(data.overall.score) },
+          { label: "Rating", value: data.overall.rating, formatted: ratingLabel(data.overall.rating) },
+          { label: "Previous close", value: data.overall.previousClose, formatted: formatScore(data.overall.previousClose) },
+          { label: "1 week ago", value: data.overall.previousWeek, formatted: formatScore(data.overall.previousWeek) },
+          { label: "1 month ago", value: data.overall.previousMonth, formatted: formatScore(data.overall.previousMonth) },
+          { label: "1 year ago", value: data.overall.previousYear, formatted: formatScore(data.overall.previousYear) },
+          { label: "Updated at", value: data.overall.updatedAt?.toISOString() ?? null },
+        ],
+      },
+      {
+        title: "Indicators",
+        columns: [
+          { key: "indicator", header: "Indicator" },
+          { key: "score", header: "Score", align: "right", format: (value) => formatScore(value as number | null) },
+          { key: "rating", header: "Rating" },
+          { key: "latest", header: "Latest", align: "right" },
+          { key: "secondary", header: "Comparison", align: "right" },
+          { key: "updatedAt", header: "Updated at" },
+        ],
+        rows: data.indicators.map((indicator) => ({
+          id: indicator.definition.id,
+          indicator: indicator.definition.title,
+          description: indicator.definition.subtitle,
+          score: indicator.score,
+          rating: indicator.rating,
+          latestValue: indicator.latestValue,
+          latest: formatIndicatorValue(indicator.latestValue, indicator.definition.valueFormat),
+          secondaryValue: indicator.latestSecondaryValue,
+          secondary: indicator.definition.secondaryLabel && indicator.latestSecondaryValue != null
+            ? `${indicator.definition.secondaryLabel}: ${formatIndicatorValue(indicator.latestSecondaryValue, indicator.definition.valueFormat)}`
+            : "-",
+          updatedAt: indicator.updatedAt?.toISOString() ?? null,
+        })),
+      },
+    ],
+  };
+}
+
+export interface FearGreedHeadlessDependencies {
+  load(args: HeadlessPaneLoadArgs, signal: AbortSignal): Promise<FearGreedLoadResult>;
+}
+
+const defaultDependencies: FearGreedHeadlessDependencies = {
+  load: (_args, signal) => loadFearGreed(false, () => fetchFearGreedData({
+    fetcher: (url, init) => httpFetch(url, { ...init, signal }),
+  })),
+};
+
+export function createFearGreedHeadless(
+  dependencies: FearGreedHeadlessDependencies = defaultDependencies,
+): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle",
+    argument: { kind: "none" },
+    options: [],
+    describe: "Fear & Greed",
+    async load(args, ctx) {
+      const result = await dependencies.load(args, ctx.signal);
+      const projected = projectFearGreedHeadless(result.data);
+      return {
+        ...projected,
+        ...(result.refreshError ? { errors: [result.refreshError] } : {}),
+        metadata: { fetchedAt: result.fetchedAt, stale: result.stale },
+      };
+    },
+  };
+}
+
+export const fearGreedHeadless = createFearGreedHeadless();

package/src/plugins/builtin/fear-greed/index.tsx

@@ -0,0 +1,89 @@
+import { CLI_COMMAND_GROUPS } from "../../../cli/help";
+import type { GloomPlugin } from "../../../types/plugin";
+import {
+  attachFearGreedPersistence,
+  loadFearGreed,
+  resetFearGreedPersistence,
+} from "./cache";
+import { FearGreedPane } from "./pane";
+import { fearGreedHeadless } from "./headless";
+
+export { fearGreedHeadless } from "./headless";
+
+export const fearGreedPlugin: GloomPlugin = {
+  id: "fear-greed",
+  name: "Fear & Greed",
+  version: "1.0.0",
+  description: "CNN Fear & Greed index with the seven indicator charts",
+  toggleable: true,
+
+  // One JSON endpoint over HTTPS, so every renderer. CNN sends no CORS
+  // headers and wants a Referer, which is why the host is declared: the web
+  // app proxies it.
+  targets: ["cli", "tui", "desktop", "web"],
+  hosts: ["production.dataviz.cnn.io"],
+
+  setup(ctx) {
+    attachFearGreedPersistence(ctx.persistence);
+  },
+
+  dispose() {
+    resetFearGreedPersistence();
+  },
+
+  panes: [
+    {
+      id: "fear-greed",
+      name: "Fear & Greed",
+      icon: "G",
+      component: FearGreedPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 110, height: 36 },
+    },
+  ],
+
+  paneTemplates: [
+    {
+      id: "fear-greed-pane",
+      paneId: "fear-greed",
+      label: "Fear & Greed",
+      description: "CNN Fear & Greed sentiment gauge with the seven indicator charts.",
+      keywords: ["fear", "greed", "sentiment", "cnn", "market", "indicators", "gauge"],
+      shortcut: { prefix: "FNG" },
+      headless: fearGreedHeadless,
+    },
+  ],
+
+  // `gloomberb fear-greed`, as before the plugin moved out of the host. Runs
+  // without the pane cache attached when invoked from the CLI, so it always
+  // fetches, which is what a CLI call wants anyway.
+  cliCommands: [
+    {
+      name: "fear-greed",
+      description: "Fetch CNN Fear & Greed gauge data",
+      help: { group: CLI_COMMAND_GROUPS.markets },
+      async execute(_args, ctx) {
+        const { data } = await loadFearGreed(ctx.cliOptions.refresh);
+        ctx.printResult({
+          data: [{
+            score: data.overall.score,
+            rating: data.overall.rating,
+            updatedAt: data.overall.updatedAt?.toISOString() ?? "",
+            previousClose: data.overall.previousClose,
+            previousWeek: data.overall.previousWeek,
+            previousMonth: data.overall.previousMonth,
+            previousYear: data.overall.previousYear,
+          }],
+          metadata: {
+            indicators: data.indicators.map((indicator) => ({
+              id: indicator.definition.id,
+              score: indicator.score,
+              rating: indicator.rating,
+            })),
+          },
+        });
+      },
+    },
+  ],
+};