gloomberb 0.15.2 → 0.15.3

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

@@ -1,87 +0,0 @@
-import { isUsableRatio, type RatioPoint } from "./align";
-import type { IndicatorDef } from "./defs";
-
-const MS_PER_DAY = 86_400_000;
-
-export interface TrendFit {
-  model: "log" | "linear";
-  alpha: number;
-  beta: number;
-  sigma: number;
-  originMs: number;
-}
-
-function parseDateMs(date: string): number {
-  return Date.parse(date);
-}
-
-/**
- * Least-squares fit of value against time. A log fit suits a level that compounds;
- * a measure that can sit at or below zero, like an excess yield, needs the linear
- * one, since taking logs would silently drop exactly its most extreme years.
- */
-export function fitTrend(
-  points: readonly RatioPoint[],
-  model: "log" | "linear" = "log",
-): TrendFit {
-  const usable = points.filter(isUsableRatio).filter((p) => model !== "log" || p.ratio > 0);
-  const empty: TrendFit = { model, alpha: 0, beta: 0, sigma: 0, originMs: 0 };
-  if (usable.length === 0) return empty;
-
-  const originMs = parseDateMs(usable[0]!.date);
-  const project = (value: number) => (model === "log" ? Math.log(value) : value);
-  if (usable.length < 2) {
-    return { model, alpha: project(usable[0]!.ratio), beta: 0, sigma: 0, originMs };
-  }
-
-  const xs: number[] = [];
-  const ys: number[] = [];
-  for (const point of usable) {
-    xs.push((parseDateMs(point.date) - originMs) / MS_PER_DAY);
-    ys.push(project(point.ratio));
-  }
-  const n = xs.length;
-  let sumX = 0;
-  let sumY = 0;
-  let sumXX = 0;
-  let sumXY = 0;
-  for (let i = 0; i < n; i += 1) {
-    sumX += xs[i]!;
-    sumY += ys[i]!;
-    sumXX += xs[i]! * xs[i]!;
-    sumXY += xs[i]! * ys[i]!;
-  }
-  const denom = n * sumXX - sumX * sumX;
-  const beta = denom === 0 ? 0 : (n * sumXY - sumX * sumY) / denom;
-  const alpha = (sumY - beta * sumX) / n;
-  if (n < 3) return { model, alpha, beta, sigma: 0, originMs };
-
-  let residualSq = 0;
-  for (let i = 0; i < n; i += 1) {
-    const residual = ys[i]! - (alpha + beta * xs[i]!);
-    residualSq += residual * residual;
-  }
-  return { model, alpha, beta, sigma: Math.sqrt(residualSq / (n - 2)), originMs };
-}
-
-export function fitIndicatorTrend(
-  indicator: IndicatorDef,
-  points: readonly RatioPoint[],
-): TrendFit {
-  return fitTrend(points, indicator.trendModel);
-}
-
-export function trendAt(fit: TrendFit, date: string): number {
-  const tDays = (parseDateMs(date) - fit.originMs) / MS_PER_DAY;
-  const fitted = fit.alpha + fit.beta * tDays;
-  return fit.model === "log" ? Math.exp(fitted) : fitted;
-}
-
-export function sigmaVsTrend(fit: TrendFit, value: number, date: string): number {
-  if (!(fit.sigma > 0)) return 0;
-  if (fit.model === "linear") {
-    return (value - trendAt(fit, date)) / fit.sigma;
-  }
-  if (!(value > 0)) return 0;
-  return (Math.log(value) - Math.log(trendAt(fit, date))) / fit.sigma;
-}

package/src/plugins/builtin/money-markets/model.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { MoneyMarketRow, MoneyMarketsPayload } from "../../../api-client/money-markets";
-import { ApiRequestError } from "../../../api-client/errors";
-import { fetchMoneyMarkets, validateMoneyMarkets } from "./client";
-import { moneyMarketCurves, moneyMarketHistory, moneyMarketNotices, moneyMarketRows } from "./model";
-
-function row(id = "sofr", overrides: Partial<MoneyMarketRow> = {}): MoneyMarketRow {
-  return { id, label: id, seriesId: "SOFR", sourceSeriesIds: ["SOFR"], sourceUrl: null,
-    group: "rates", unit: "percent", frequency: "daily", value: 0, asOf: "2026-09-21", previousValue: -0.01,
-    previousAsOf: "2026-09-18", change: 1, changeUnit: "basis-points",
-    percentile: { value: 50, rank: 2, sampleCount: 4, windowStart: "2025-09-21", windowEnd: "2026-09-21", min: -0.01, max: 0, mean: 0 },
-    history: [{ date: "2026-09-18", value: -0.01 }, { date: "2026-09-21", value: 0 }], status: "available", fetchedAt: "2026-09-22T10:00:00Z", unavailableReason: null, notes: [], ...overrides };
-}
-function payload(): MoneyMarketsPayload {
-  return { generatedAt: "2026-09-22T10:00:00Z", status: "available", rows: [row()],
-    netLiquidity: row("net-liquidity", { group: "liquidity", unit: "usd-billions", changeUnit: "usd-billions" }),
-    billsCurve: { asOf: "2026-09-21", status: "available", basis: "discount",
-      points: [{ tenor: "4W", maturityYears: 28 / 365, seriesId: "DTB4WK", value: 0 }],
-      comparisons: [{ period: "1W", targetDate: "2026-09-14", asOf: "2026-09-11", points: [{ tenor: "4W", maturityYears: 28 / 365, seriesId: "DTB4WK", value: -0.1 }] }, { period: "1Y", targetDate: "2025-09-21", asOf: null, points: [] }],
-      slope: { valueBps: null, asOf: null, percentile: row().percentile, history: [] } } };
-}
-
-describe("money-market boundary", () => {
-  test("keeps explicit zero, negative rates and a partially missing source", () => {
-    const data = payload();
-    data.status = "partial";
-    data.rows.push(row("effr", { value: null, asOf: null, change: null, history: [], status: "unavailable", unavailableReason: "metadata-mismatch" }));
-    expect(validateMoneyMarkets(data).rows[0]?.value).toBe(0);
-    expect(moneyMarketRows(data, "rates")).toHaveLength(2);
-    expect(moneyMarketNotices(data)).toContain("effr: metadata mismatch.");
-    expect(moneyMarketRows(data, "liquidity").map((row) => row.id)).toEqual(["net-liquidity"]);
-  });
-  test("rejects impossible dates, nonfinite rates, incompatible units and undated curves", () => {
-    for (const mutate of [
-      (data: MoneyMarketsPayload) => { data.rows[0]!.asOf = "2026-02-30"; },
-      (data: MoneyMarketsPayload) => { data.rows[0]!.value = NaN; },
-      (data: MoneyMarketsPayload) => { data.rows[0]!.changeUnit = "usd-billions"; },
-      (data: MoneyMarketsPayload) => { data.rows[0]!.percentile.value = 101; },
-      (data: MoneyMarketsPayload) => { data.billsCurve.asOf = null; },
-      (data: MoneyMarketsPayload) => { data.rows[0]!.percentile.windowStart = "2025-02-29"; },
-    ]) { const data = payload(); mutate(data); expect(() => validateMoneyMarkets(data)).toThrow(); }
-  });
-  test("preserves distinct ghost dates and omits unavailable comparisons", () => {
-    const curves = moneyMarketCurves(payload());
-    expect(curves.map((curve) => [curve.id, curve.asOf])).toEqual([["today", "2026-09-21"], ["1W", "2026-09-11"]]);
-    expect(curves[1]?.points[0]?.value).toBe(-0.1);
-    expect(curves[1]?.points[0]?.asOf).toBe("2026-09-11");
-  });
-  test("history charts use the percentile window and retain explicit gaps", () => {
-    const observation = row("sofr", { history: [
-      { date: "2025-08-22", value: 9 }, { date: "2025-09-21", value: 4 },
-      { date: "2026-09-18", value: null }, { date: "2026-09-21", value: 0 },
-    ] });
-    expect(moneyMarketHistory(observation)).toEqual(observation.history.slice(1));
-  });
-  test("missing endpoint gives an actionable unavailable state without hiding auth errors", async () => {
-    await expect(fetchMoneyMarkets({ getCloudMoneyMarkets: async () => { throw new ApiRequestError("not found", 404); } })).rejects.toThrow("not available on this Gloom Cloud server yet");
-    const denied = new ApiRequestError("sign in", 401);
-    await expect(fetchMoneyMarkets({ getCloudMoneyMarkets: async () => { throw denied; } })).rejects.toBe(denied);
-  });
-});

package/src/plugins/builtin/news/headless.test.ts

@@ -1,149 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { CloudNewsPayload } from "../../../api-client";
-import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
-import type { NewsQuery } from "../../../news/types";
-import {
-  createNewsFeedHeadless,
-  createTickerNewsHeadless,
-  type NewsHeadlessDependencies,
-} from "./headless";
-
-function story(
-  id: string,
-  sentiment: CloudNewsPayload["sentiment"],
-  importance: number,
-  publishedAt: string,
-): CloudNewsPayload {
-  return {
-    id,
-    headline: `${id} headline`,
-    summary: `${id} summary`,
-    category: "markets",
-    sentiment,
-    sectors: ["technology"],
-    firstPublishedAt: publishedAt,
-    lastPublishedAt: publishedAt,
-    firstSeenAt: publishedAt,
-    lastSeenAt: publishedAt,
-    primaryUrl: `https://example.com/${id}`,
-    primarySource: "Example Wire",
-    scores: {
-      importance,
-      urgency: importance - 1,
-      marketImpact: importance - 2,
-      novelty: 7,
-      confidence: 90,
-    },
-    flags: { breaking: importance > 80 },
-    variantCount: 1,
-    sourceCount: 1,
-    sources: ["Example Wire"],
-    entities: [],
-    tickerLinks: [{
-      symbol: "AMD",
-      exchange: "NASDAQ",
-      canonicalTicker: "AMD",
-      relationType: "issuer",
-      displayTier: "primary",
-      confidence: 1,
-      relevanceScore: 1,
-    }],
-  };
-}
-
-const stories = [
-  story("newer", "positive", 95, "2026-09-04T20:00:00.000Z"),
-  story("older", "negative", 70, "2026-09-04T18:00:00.000Z"),
-];
-
-function args(
-  symbol: string | null,
-  options: Record<string, string | number | boolean>,
-): HeadlessPaneLoadArgs {
-  return {
-    rawArgument: symbol ?? "",
-    argument: symbol,
-    symbols: symbol ? [symbol] : [],
-    options,
-  };
-}
-
-const context = {} as HeadlessPaneContext;
-
-function dependencies(seen: NewsQuery[]): NewsHeadlessDependencies {
-  return {
-    loadNews: async (query) => {
-      seen.push(query);
-      return { items: stories, nextCursor: "page-2" };
-    },
-    now: () => new Date("2026-09-04T21:00:00.000Z"),
-  };
-}
-
-describe("news feed headless", () => {
-  test("maps cloud stories into a point-in-time snapshot", async () => {
-    const seen: NewsQuery[] = [];
-    const definition = createNewsFeedHeadless(dependencies(seen));
-
-    const result = await definition.load(
-      args(null, { sentiment: "any", minImportance: 0, limit: 50 }),
-      context,
-    );
-
-    expect(result.asOf).toBe("2026-09-04T21:00:00.000Z");
-    expect(result.items[0]).toMatchObject({
-      id: "newer",
-      headline: "newer headline",
-      tickers: ["AMD"],
-      sentiment: "positive",
-      importance: 95,
-      breaking: true,
-      sourceCount: 1,
-    });
-    expect(seen[0]).toMatchObject({ feed: "latest", limit: 50 });
-  });
-
-  test("applies sentiment and importance options", async () => {
-    const definition = createNewsFeedHeadless(dependencies([]));
-
-    const result = await definition.load(
-      args(null, { sentiment: "positive", minImportance: 90, limit: 50 }),
-      context,
-    );
-
-    expect(result.items.map((item) => item.id)).toEqual(["newer"]);
-  });
-});
-
-describe("ticker news headless", () => {
-  test("requests the ticker feed and applies the row limit", async () => {
-    const seen: NewsQuery[] = [];
-    const definition = createTickerNewsHeadless(dependencies(seen));
-
-    const result = await definition.load(
-      args("AMD:XNAS", { sentiment: "any", minImportance: 0, limit: 1 }),
-      context,
-    );
-
-    expect(seen[0]).toMatchObject({
-      feed: "ticker",
-      ticker: "AMD",
-      exchange: "NASDAQ",
-      tickerTier: "primary",
-      limit: 1,
-    });
-    expect(result.items).toHaveLength(1);
-    expect(result.metadata).toMatchObject({ truncated: true });
-  });
-
-  test("asks for the saved listing of a bare symbol listed on several exchanges", async () => {
-    const seen: NewsQuery[] = [];
-    const definition = createTickerNewsHeadless(dependencies(seen));
-
-    await definition.load(args("NVDA", { sentiment: "any", minImportance: 0, limit: 5 }), {
-      resolveInstrument: async (symbol: string) => ({ symbol, exchange: "NASDAQ" }),
-    } as unknown as HeadlessPaneContext);
-
-    expect(seen[0]).toMatchObject({ feed: "ticker", ticker: "NVDA", exchange: "NASDAQ" });
-  });
-});

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

@@ -1,99 +0,0 @@
-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/notifications.test.ts

@@ -1,204 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { AppNotificationRequest, GloomPluginContext } from "../../../../../types/plugin";
-import type { MarketNewsItem, NewsQueryState } from "../../../../../types/news-source";
-import {
-  BREAKING_NEWS_MUTED_SECTORS_KEY,
-  BREAKING_NEWS_SCOPE_KEY,
-} from "./filters";
-import {
-  BREAKING_NEWS_NOTIFICATIONS_ENABLED_KEY,
-  setupBreakingNewsNotifications,
-} from "./notifications";
-
-function article(
-  id: string,
-  title = id,
-  overrides: Partial<MarketNewsItem> = {},
-): MarketNewsItem {
-  return {
-    id,
-    title,
-    url: `https://example.com/${id}`,
-    source: "Test Wire",
-    publishedAt: new Date(),
-    topic: "general",
-    topics: ["general"],
-    sectors: [],
-    categories: ["general"],
-    tickers: ["AAPL"],
-    scores: { importance: 90, urgency: 90, marketImpact: 80, novelty: 80, confidence: 90 },
-    importance: 90,
-    isBreaking: true,
-    isDeveloping: false,
-    ...overrides,
-  };
-}
-
-function ready(articles: MarketNewsItem[]): NewsQueryState {
-  return {
-    phase: "ready",
-    articles,
-    error: null,
-    updatedAt: Date.now(),
-    sourceIds: ["test"],
-    nextCursor: null,
-    loadingMore: false,
-  };
-}
-
-interface Harness {
-  ctx: GloomPluginContext;
-  notifications: AppNotificationRequest[];
-  shownPanes: string[];
-  state: Map<string, unknown>;
-  emit(articles: MarketNewsItem[]): void;
-  isWatching(): boolean;
-}
-
-function harness(options: {
-  settings?: Record<string, unknown>;
-  watchedSymbols?: string[];
-} = {}): Harness {
-  let listener: ((state: NewsQueryState) => void) | null = null;
-  const notifications: AppNotificationRequest[] = [];
-  const shownPanes: string[] = [];
-  const state = new Map<string, unknown>();
-  const settings: Record<string, unknown> = {
-    [BREAKING_NEWS_NOTIFICATIONS_ENABLED_KEY]: true,
-    ...options.settings,
-  };
-  const watched = options.watchedSymbols ?? ["AAPL"];
-
-  const ctx = {
-    configState: { get: (key: string) => settings[key] ?? null },
-    persistence: {
-      getState: (key: string) => state.get(key) ?? null,
-      setState: (key: string, value: unknown) => void state.set(key, value),
-    },
-    tickerRepository: {
-      loadAllTickers: async () =>
-        watched.map((symbol) => ({
-          metadata: { ticker: symbol, watchlists: ["default"], portfolios: [], positions: [] },
-        })),
-    },
-    watchNewsQuery: (_query: unknown, next: (state: NewsQueryState) => void) => {
-      listener = next;
-      return () => {
-        listener = null;
-      };
-    },
-    on: () => () => {},
-    notify: (notification: AppNotificationRequest) => void notifications.push(notification),
-    showPane: (paneId: string) => void shownPanes.push(paneId),
-    log: { warn: () => {} },
-  } as unknown as GloomPluginContext;
-
-  return {
-    ctx,
-    notifications,
-    shownPanes,
-    state,
-    emit: (articles) => listener?.(ready(articles)),
-    isWatching: () => listener !== null,
-  };
-}
-
-/** Lets the async watchlist load settle before articles arrive. */
-const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
-
-describe("breaking news notifications", () => {
-  test("primes on the first ready batch and notifies for later unseen articles", async () => {
-    const h = harness();
-    const dispose = setupBreakingNewsNotifications(h.ctx);
-    await settle();
-
-    const old = article("old", "Old headline");
-    const fresh = article("new", "New headline");
-
-    h.emit([old]);
-    h.emit([fresh, old]);
-
-    expect(h.notifications).toHaveLength(1);
-    expect(h.notifications[0]).toMatchObject({
-      title: "Breaking News",
-      body: "New headline",
-      desktop: "always",
-    });
-    // Breaking toasts must expire on their own; persistent ones stacked up.
-    expect(h.notifications[0]?.persistent).toBeUndefined();
-    expect(h.notifications[0]?.duration).toBeGreaterThan(0);
-
-    h.notifications[0]!.action?.onClick();
-    expect(h.shownPanes).toEqual(["news-breaking"]);
-
-    dispose();
-    expect(h.isWatching()).toBe(false);
-  });
-
-  test("default scope drops stories about tickers the user does not track", async () => {
-    const h = harness({ watchedSymbols: ["AAPL"] });
-    setupBreakingNewsNotifications(h.ctx);
-    await settle();
-
-    h.emit([article("seed")]);
-    h.emit([
-      article("unrelated", "Unrelated ticker", { tickers: ["XOM"] }),
-      article("seed"),
-    ]);
-    expect(h.notifications).toHaveLength(0);
-
-    h.emit([article("macro", "Market-wide event", { tickers: [] }), article("seed")]);
-    expect(h.notifications).toHaveLength(1);
-    expect(h.notifications[0]?.body).toBe("Market-wide event");
-  });
-
-  test("muted sectors suppress otherwise in-scope stories", async () => {
-    const h = harness({
-      settings: { [BREAKING_NEWS_MUTED_SECTORS_KEY]: ["health_care"] },
-    });
-    setupBreakingNewsNotifications(h.ctx);
-    await settle();
-
-    h.emit([article("seed")]);
-    h.emit([
-      article("pharma", "Pharma story", { sectors: ["health_care"] }),
-      article("seed"),
-    ]);
-    expect(h.notifications).toHaveLength(0);
-  });
-
-  test("filtered-out articles are still marked seen so relaxing a filter replays nothing", async () => {
-    const h = harness({ settings: { [BREAKING_NEWS_SCOPE_KEY]: "watchlist" } });
-    setupBreakingNewsNotifications(h.ctx);
-    await settle();
-
-    h.emit([article("seed")]);
-    const macro = article("macro", "Market-wide event", { tickers: [] });
-    h.emit([macro, article("seed")]);
-    expect(h.notifications).toHaveLength(0);
-
-    // Same article arriving again must not notify once it has been observed.
-    h.emit([macro, article("seed")]);
-    expect(h.notifications).toHaveLength(0);
-  });
-
-  test("snoozing suppresses notifications until the window passes", async () => {
-    const h = harness();
-    setupBreakingNewsNotifications(h.ctx);
-    await settle();
-
-    h.emit([article("seed")]);
-    h.emit([article("first", "First"), article("seed")]);
-    expect(h.notifications).toHaveLength(1);
-
-    h.notifications[0]!.secondaryAction?.onClick();
-    const confirmation = h.notifications.length;
-
-    h.emit([article("second", "Second"), article("seed")]);
-    expect(h.notifications).toHaveLength(confirmation);
-
-    h.state.set("breaking-news-snooze-until", Date.now() - 1);
-    h.emit([article("third", "Third"), article("seed")]);
-    expect(h.notifications.at(-1)?.body).toBe("Third");
-  });
-});