gloomberb 0.6.1 → 0.7.0

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

@@ -34,11 +34,6 @@ const MIN_CORRELATION_OBSERVATIONS = 5;
 
 type SeriesStatus = "loading" | "ready" | "insufficient" | "empty" | "error";
 
-interface CorrelationInstrument {
-  symbol: string;
-  exchange: string;
-}
-
 interface CorrelationSeries {
   symbol: string;
   returns: DatedReturn[];
@@ -147,7 +142,7 @@ function buildCorrelationPaneTitle(symbols: string[], rangePreset: CorrelationRa
   return `${symbols.slice(0, 2).join(" · ")} +${symbols.length - 2} ${rangePreset}`;
 }
 
-export function CorrelationMatrixPane({ width, height }: PaneProps) {
+function CorrelationMatrixPane({ width, height }: PaneProps) {
   const pane = usePaneInstance();
   const { navigateTicker } = usePluginTickerActions();
   const tickers = useAppSelector((state) => state.tickers);

package/src/plugins/builtin/debug.tsx

@@ -62,7 +62,6 @@ function DebugPane({ focused, width, height }: PaneProps) {
   const [filterLevel, setFilterLevel] = useState<LogLevel | null>(null);
   const [filterSource, setFilterSource] = useState<string | null>(null);
   const [autoScroll, setAutoScroll] = useState(true);
-  const [scrollOffset, setScrollOffset] = useState(0);
   const [selectedIdx, setSelectedIdx] = useState(-1);
   const [hoveredIdx, setHoveredIdx] = useState<number | null>(null);
   const [showDetail, setShowDetail] = useState(false);
@@ -77,7 +76,6 @@ function DebugPane({ focused, width, height }: PaneProps) {
       );
       setEntries(filtered);
       sourcesRef.current = debugLog.getSources();
-      if (autoScroll) setScrollOffset(0);
     });
     return unsub;
   }, [filterLevel, filterSource, autoScroll]);
@@ -342,7 +340,7 @@ export const debugPlugin: GloomPlugin = {
       keywords: ["debug", "log", "logs", "console", "errors"],
       category: "navigation",
       execute: () => {
-        ctx.showWidget("debug");
+        ctx.showPane("debug");
       },
     });
 

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

@@ -303,7 +303,6 @@ function EconDetailView({ event, width, height, focused }: EconDetailViewProps)
     return { date: obs.date, display: obs.value.toLocaleString("en-US", { maximumFractionDigits: 1 }) };
   });
   const units = info?.units ?? "";
-  const source = info?.source || "";
   const title = info?.title ?? event.event;
 
   // Value color for table rows
@@ -472,7 +471,7 @@ function formatCompactAxisValue(value: number, units: string): string {
 // Main Calendar Pane
 // ---------------------------------------------------------------------------
 
-export function EconCalendarPane({ focused, width, height }: PaneProps) {
+function EconCalendarPane({ focused, width, height }: PaneProps) {
   const [events, setEvents] = useState<EconEvent[]>(sharedCache?.data ?? []);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);

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

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+import { normalizeFearGreedData, type CnnFearGreedGraphData } from "./fear-greed-data";
+
+describe("fear-greed data normalization", () => {
+  test("combines latest score with chart history and aligned overlay series", () => {
+    const charts: CnnFearGreedGraphData = {
+      fear_and_greed: {
+        score: 65,
+        rating: "greed",
+        timestamp: "2026-05-08T23:59:55+00:00",
+      },
+      fear_and_greed_historical: {
+        score: 65,
+        rating: "greed",
+        data: [
+          { x: 2000, y: 62, rating: "greed" },
+          { x: 1000, y: 58, rating: "greed" },
+        ],
+      },
+      market_momentum_sp500: {
+        score: 99.6,
+        rating: "extreme greed",
+        timestamp: 2000,
+        data: [
+          { x: 1000, y: 100 },
+          { x: 2000, y: 110 },
+        ],
+      },
+      market_momentum_sp125: {
+        timestamp: 2000,
+        data: [
+          { x: 1000, y: 92 },
+          { x: 2000, y: 96 },
+        ],
+      },
+      stock_price_strength: {
+        score: 61.4,
+        rating: "greed",
+        data: [{ x: 1000, y: 3.8 }],
+      },
+    };
+    const latest: CnnFearGreedGraphData = {
+      fear_and_greed: {
+        score: 70.4,
+        rating: "greed",
+        timestamp: "2026-05-09T12:00:00+00:00",
+        previous_close: 67.5,
+        previous_1_week: 71.1,
+        previous_1_month: 29.1,
+        previous_1_year: 57.6,
+      },
+    };
+
+    const data = normalizeFearGreedData(charts, latest);
+
+    expect(data.overall.score).toBe(70.4);
+    expect(data.overall.previousClose).toBe(67.5);
+    expect(data.overall.history.map((point) => point.close)).toEqual([58, 62]);
+
+    const momentum = data.indicators.find((indicator) => indicator.definition.id === "market-momentum");
+    expect(momentum?.rating).toBe("extreme greed");
+    expect(momentum?.points.map((point) => point.close)).toEqual([100, 110]);
+    expect(momentum?.secondaryPoints).toEqual([
+      { index: 0, value: 92 },
+      { index: 1, value: 96 },
+    ]);
+  });
+
+  test("rejects responses without an index score", () => {
+    expect(() => normalizeFearGreedData({})).toThrow("index score");
+  });
+});

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

@@ -0,0 +1,366 @@
+import type { ProjectedChartPoint } from "../../../components/chart/chart-data";
+import type { OverlayPoint } from "../../../components/chart/indicators/types";
+
+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;
+}
+
+export 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";
+
+export interface FearGreedIndicatorDefinition {
+  id: string;
+  title: string;
+  subtitle: string;
+  primaryKey: CnnGraphKey;
+  primaryLabel: string;
+  secondaryKey?: CnnGraphKey;
+  secondaryLabel?: string;
+  valueFormat: FearGreedValueFormat;
+}
+
+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[];
+}
+
+export 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}`;
+}
+
+function isDomRuntime(): boolean {
+  return typeof (globalThis as { document?: unknown }).document !== "undefined";
+}
+
+function cnnFetchHeaders(): HeadersInit {
+  const headers: Record<string, string> = {
+    Accept: "application/json,text/plain,*/*",
+  };
+
+  if (!isDomRuntime()) {
+    headers["User-Agent"] = CNN_USER_AGENT;
+    headers.Referer = CNN_REFERER;
+  }
+
+  return headers;
+}
+
+async function fetchCnnGraphData(url: string, fetcher: typeof fetch): 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?: typeof fetch;
+} = {}): Promise<FearGreedData> {
+  const fetcher = options.fetcher ?? fetch;
+  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.reason;
+    throw reason instanceof Error ? reason : new Error(String(reason));
+  }
+
+  return normalizeFearGreedData(charts ?? latest!, latest ?? charts ?? undefined);
+}