gloomberb 0.7.4 → 0.8.0

package/src/plugins/builtin/earnings/earnings-cache.test.ts

@@ -1,181 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import type { DataProvider, EarningsEvent } from "../../../types/data-provider";
-import type { PersistedResourceValue } from "../../../types/persistence";
-import type { PluginPersistence } from "../../../types/plugin";
-import {
-  attachEarningsCalendarPersistence,
-  buildEarningsCacheKey,
-  EARNINGS_CALENDAR_CACHE_POLICY,
-  loadEarningsCalendar,
-  resetEarningsCalendarPersistence,
-} from "./earnings-cache";
-
-class MemoryPluginPersistence implements PluginPersistence {
-  private readonly resources = new Map<string, PersistedResourceValue<unknown>>();
-  private readonly state = new Map<string, { schemaVersion: number; value: unknown }>();
-
-  getState<T = unknown>(key: string, options?: { schemaVersion?: number }): T | null {
-    const record = this.state.get(key);
-    if (!record) return null;
-    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) return null;
-    return record.value as T;
-  }
-
-  setState(key: string, value: unknown, options?: { schemaVersion?: number }): void {
-    this.state.set(key, { schemaVersion: options?.schemaVersion ?? 1, value });
-  }
-
-  deleteState(key: string): void {
-    this.state.delete(key);
-  }
-
-  getResource<T = unknown>(
-    kind: string,
-    key: string,
-    options?: { sourceKey?: string; schemaVersion?: number; allowExpired?: boolean },
-  ): PersistedResourceValue<T> | null {
-    const record = this.resources.get(this.resourceKey(kind, key, options?.sourceKey));
-    if (!record) return null;
-    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) return null;
-    const next = this.withFreshness(record);
-    if (!options?.allowExpired && next.expired) return null;
-    return next as PersistedResourceValue<T>;
-  }
-
-  setResource<T = unknown>(
-    kind: string,
-    key: string,
-    value: T,
-    options: {
-      cachePolicy: { staleMs: number; expireMs: number };
-      sourceKey?: string;
-      schemaVersion?: number;
-      provenance?: unknown;
-    },
-  ): PersistedResourceValue<T> {
-    const now = Date.now();
-    const record: PersistedResourceValue<T> = {
-      value,
-      fetchedAt: now,
-      staleAt: now + options.cachePolicy.staleMs,
-      expiresAt: now + options.cachePolicy.expireMs,
-      sourceKey: options.sourceKey ?? "",
-      schemaVersion: options.schemaVersion ?? 1,
-      provenance: options.provenance,
-      stale: false,
-      expired: false,
-    };
-    this.resources.set(this.resourceKey(kind, key, options.sourceKey), record);
-    return record;
-  }
-
-  deleteResource(kind: string, key: string, options?: { sourceKey?: string }): void {
-    this.resources.delete(this.resourceKey(kind, key, options?.sourceKey));
-  }
-
-  seedResource<T>(
-    kind: string,
-    key: string,
-    value: T,
-    options: { sourceKey?: string; stale?: boolean; expired?: boolean; schemaVersion?: number } = {},
-  ): void {
-    const now = Date.now();
-    const record: PersistedResourceValue<T> = {
-      value,
-      fetchedAt: now - 60_000,
-      staleAt: options.stale ? now - 1 : now + EARNINGS_CALENDAR_CACHE_POLICY.staleMs,
-      expiresAt: options.expired ? now - 1 : now + EARNINGS_CALENDAR_CACHE_POLICY.expireMs,
-      sourceKey: options.sourceKey ?? "",
-      schemaVersion: options.schemaVersion ?? 2,
-      stale: !!options.stale,
-      expired: !!options.expired,
-    };
-    this.resources.set(this.resourceKey(kind, key, options.sourceKey), record);
-  }
-
-  private resourceKey(kind: string, key: string, sourceKey = ""): string {
-    return `${kind}:${key}:${sourceKey}`;
-  }
-
-  private withFreshness<T>(record: PersistedResourceValue<T>): PersistedResourceValue<T> {
-    const now = Date.now();
-    return {
-      ...record,
-      stale: now >= record.staleAt,
-      expired: now >= record.expiresAt,
-    };
-  }
-}
-
-function eventFor(symbol: string): EarningsEvent {
-  return {
-    symbol,
-    name: `${symbol} Corp`,
-    earningsDate: new Date("2026-05-01T12:00:00Z"),
-    epsEstimate: 1.23,
-    epsActual: null,
-    revenueEstimate: 1_000_000,
-    revenueActual: null,
-    surprise: null,
-    timing: "",
-  };
-}
-
-afterEach(() => {
-  resetEarningsCalendarPersistence();
-});
-
-describe("buildEarningsCacheKey", () => {
-  test("normalizes symbol order, case, and duplicates", () => {
-    expect(buildEarningsCacheKey([" msft ", "AAPL", "aapl"])).toBe("AAPL,MSFT");
-  });
-});
-
-describe("loadEarningsCalendar", () => {
-  test("keeps separate caches for different symbol sets", async () => {
-    const calls: string[][] = [];
-    const provider = {
-      id: "test",
-      name: "Test",
-      getEarningsCalendar: async (symbols: string[]) => {
-        calls.push(symbols);
-        return symbols.map(eventFor);
-      },
-    } as DataProvider;
-
-    const aapl = await loadEarningsCalendar(provider, ["AAPL"]);
-    const msft = await loadEarningsCalendar(provider, ["MSFT"]);
-    const aaplAgain = await loadEarningsCalendar(provider, ["aapl"]);
-
-    expect(aapl.map((event) => event.symbol)).toEqual(["AAPL"]);
-    expect(msft.map((event) => event.symbol)).toEqual(["MSFT"]);
-    expect(aaplAgain.map((event) => event.symbol)).toEqual(["AAPL"]);
-    expect(calls).toEqual([["AAPL"], ["MSFT"]]);
-  });
-
-  test("falls back to stale persisted data when refresh fails", async () => {
-    const persistence = new MemoryPluginPersistence();
-    attachEarningsCalendarPersistence(persistence);
-    persistence.seedResource("calendar", "AAPL", [{
-      ...eventFor("AAPL"),
-      earningsDate: "2026-05-01T12:00:00.000Z",
-    }], {
-      sourceKey: "earnings",
-      stale: true,
-    });
-
-    const provider = {
-      id: "test",
-      name: "Test",
-      getEarningsCalendar: async () => {
-        throw new Error("offline");
-      },
-    } as DataProvider;
-
-    const events = await loadEarningsCalendar(provider, ["AAPL"], { force: true });
-
-    expect(events).toHaveLength(1);
-    expect(events[0]!.symbol).toBe("AAPL");
-    expect(events[0]!.earningsDate).toBeInstanceOf(Date);
-  });
-});

package/src/plugins/builtin/earnings/earnings-cache.ts

@@ -1,145 +0,0 @@
-import type { DataProvider, EarningsEvent } from "../../../types/data-provider";
-import type { PersistedResourceValue } from "../../../types/persistence";
-import type { PluginPersistence } from "../../../types/plugin";
-
-const CACHE_KIND = "calendar";
-const CACHE_SOURCE = "earnings";
-const CACHE_SCHEMA_VERSION = 2;
-
-export const EARNINGS_CALENDAR_CACHE_POLICY = {
-  staleMs: 30 * 60 * 1000,
-  expireMs: 7 * 24 * 60 * 60 * 1000,
-} as const;
-
-interface MemoryCacheEntry {
-  data: EarningsEvent[];
-  fetchedAt: number;
-}
-
-type PersistedEarningsEvent = Omit<EarningsEvent, "earningsDate" | "earningsCallDate"> & {
-  earningsDate: string;
-  earningsCallDate?: string | null;
-};
-
-let earningsPersistence: PluginPersistence | null = null;
-const memoryCache = new Map<string, MemoryCacheEntry>();
-const activeFetches = new Map<string, Promise<EarningsEvent[]>>();
-
-export function attachEarningsCalendarPersistence(persistence: PluginPersistence): void {
-  earningsPersistence = persistence;
-}
-
-export function resetEarningsCalendarPersistence(): void {
-  earningsPersistence = null;
-  memoryCache.clear();
-  activeFetches.clear();
-}
-
-export function normalizeEarningsSymbols(symbols: string[]): string[] {
-  return Array.from(
-    new Set(
-      symbols
-        .map((symbol) => symbol.trim().toUpperCase())
-        .filter(Boolean),
-    ),
-  ).sort();
-}
-
-export function buildEarningsCacheKey(symbols: string[]): string {
-  const normalized = normalizeEarningsSymbols(symbols);
-  return normalized.length > 0 ? normalized.join(",") : "empty";
-}
-
-function serializeEvents(events: EarningsEvent[]): PersistedEarningsEvent[] {
-  return events.map((event) => ({
-    ...event,
-    earningsDate: event.earningsDate.toISOString(),
-    earningsCallDate: event.earningsCallDate?.toISOString() ?? null,
-  }));
-}
-
-function deserializeEvents(events: PersistedEarningsEvent[]): EarningsEvent[] {
-  return events
-    .map((event) => ({
-      ...event,
-      earningsDate: new Date(event.earningsDate),
-      earningsCallDate: event.earningsCallDate ? new Date(event.earningsCallDate) : null,
-    }))
-    .filter((event) => (
-      !Number.isNaN(event.earningsDate.getTime())
-      && (
-        !event.earningsCallDate
-        || !Number.isNaN(event.earningsCallDate.getTime())
-      )
-    ));
-}
-
-function readPersistedCache(
-  key: string,
-  options?: { allowExpired?: boolean },
-): PersistedResourceValue<PersistedEarningsEvent[]> | null {
-  return earningsPersistence?.getResource<PersistedEarningsEvent[]>(CACHE_KIND, key, {
-    sourceKey: CACHE_SOURCE,
-    schemaVersion: CACHE_SCHEMA_VERSION,
-    allowExpired: options?.allowExpired,
-  }) ?? null;
-}
-
-function writeCache(key: string, events: EarningsEvent[]): void {
-  memoryCache.set(key, { data: events, fetchedAt: Date.now() });
-  earningsPersistence?.setResource(CACHE_KIND, key, serializeEvents(events), {
-    sourceKey: CACHE_SOURCE,
-    schemaVersion: CACHE_SCHEMA_VERSION,
-    cachePolicy: EARNINGS_CALENDAR_CACHE_POLICY,
-  });
-}
-
-export async function loadEarningsCalendar(
-  provider: DataProvider | null | undefined,
-  symbols: string[],
-  options?: { force?: boolean },
-): Promise<EarningsEvent[]> {
-  const normalizedSymbols = normalizeEarningsSymbols(symbols);
-  if (normalizedSymbols.length === 0 || !provider?.getEarningsCalendar) return [];
-
-  const key = buildEarningsCacheKey(normalizedSymbols);
-  const force = options?.force ?? false;
-  const memoryEntry = memoryCache.get(key);
-  if (!force && memoryEntry && Date.now() - memoryEntry.fetchedAt < EARNINGS_CALENDAR_CACHE_POLICY.staleMs) {
-    return memoryEntry.data;
-  }
-
-  const freshPersisted = readPersistedCache(key);
-  if (!force && freshPersisted && !freshPersisted.stale) {
-    const data = deserializeEvents(freshPersisted.value);
-    memoryCache.set(key, { data, fetchedAt: freshPersisted.fetchedAt });
-    return data;
-  }
-
-  const activeFetch = activeFetches.get(key);
-  if (activeFetch && !force) return activeFetch;
-
-  const fetchPromise = provider.getEarningsCalendar(normalizedSymbols)
-    .then((data) => {
-      writeCache(key, data);
-      return data;
-    })
-    .catch((error) => {
-      const stalePersisted = freshPersisted ?? readPersistedCache(key, { allowExpired: true });
-      if (stalePersisted) {
-        const data = deserializeEvents(stalePersisted.value);
-        memoryCache.set(key, { data, fetchedAt: stalePersisted.fetchedAt });
-        return data;
-      }
-      if (memoryEntry) return memoryEntry.data;
-      throw error;
-    })
-    .finally(() => {
-      if (activeFetches.get(key) === fetchPromise) {
-        activeFetches.delete(key);
-      }
-    });
-
-  activeFetches.set(key, fetchPromise);
-  return fetchPromise;
-}

package/src/plugins/builtin/earnings/earnings-data.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { parseEarningsModules, parseEarningsDate } from "./earnings-data";
-
-describe("parseEarningsDate", () => {
-  test("parses Unix timestamp", () => {
-    const d = parseEarningsDate({ raw: 1714521600 });
-    expect(d).toBeInstanceOf(Date);
-    expect(d!.getFullYear()).toBeGreaterThanOrEqual(2024);
-  });
-});
-
-describe("parseEarningsModules", () => {
-  test("extracts earnings date and estimates", () => {
-    const result = parseEarningsModules("AAPL", "Apple Inc.", {
-      calendarEvents: {
-        earnings: {
-          earningsDate: [{ raw: 1714521600 }],
-          earningsCallDate: [{ raw: 1714525200 }],
-          isEarningsDateEstimate: false,
-          earningsAverage: { raw: 1.53 },
-          earningsLow: { raw: 1.45 },
-          earningsHigh: { raw: 1.65 },
-          revenueAverage: { raw: 90500000000 },
-          revenueLow: { raw: 89500000000 },
-          revenueHigh: { raw: 92000000000 },
-        },
-      },
-      earningsTrend: { trend: [] },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.symbol).toBe("AAPL");
-    expect(result!.epsEstimate).toBe(1.53);
-    expect(result!.epsLow).toBe(1.45);
-    expect(result!.revenueHigh).toBe(92000000000);
-    expect(result!.earningsCallDate).toBeInstanceOf(Date);
-    expect(result!.isDateEstimate).toBe(false);
-    expect(result!.earningsDate).toBeInstanceOf(Date);
-  });
-
-  test("prefers earningsTrend over calendarEvents", () => {
-    const result = parseEarningsModules("AAPL", "Apple Inc.", {
-      calendarEvents: {
-        earnings: {
-          earningsDate: [{ raw: 1714521600 }],
-          earningsAverage: { raw: 1.50 },
-        },
-      },
-      earningsTrend: {
-        trend: [{
-          period: "0q",
-          earningsEstimate: {
-            avg: { raw: 1.55 },
-            low: { raw: 1.50 },
-            high: { raw: 1.60 },
-            yearAgoEps: { raw: 1.25 },
-            numberOfAnalysts: { raw: 31 },
-            growth: { raw: 0.24 },
-          },
-          revenueEstimate: {
-            avg: { raw: 91000000000 },
-            low: { raw: 90000000000 },
-            high: { raw: 93000000000 },
-            yearAgoRevenue: { raw: 83000000000 },
-            numberOfAnalysts: { raw: 29 },
-            growth: { raw: 0.096 },
-          },
-          epsTrend: {
-            "7daysAgo": { raw: 1.54 },
-            "30daysAgo": { raw: 1.48 },
-          },
-          epsRevisions: {
-            upLast7days: { raw: 1 },
-            upLast30days: { raw: 3 },
-            downLast7Days: { raw: 0 },
-            downLast30days: { raw: 2 },
-          },
-        }],
-      },
-    });
-    expect(result!.epsEstimate).toBe(1.55);
-    expect(result!.revenueEstimate).toBe(91000000000);
-    expect(result!.epsYearAgo).toBe(1.25);
-    expect(result!.epsAnalysts).toBe(31);
-    expect(result!.epsTrend30dAgo).toBe(1.48);
-    expect(result!.epsRevisionUp30d).toBe(3);
-    expect(result!.revenueGrowth).toBe(0.096);
-    expect(result!.revenueAnalysts).toBe(29);
-  });
-
-});

package/src/plugins/builtin/earnings/earnings-data.ts

@@ -1,115 +0,0 @@
-
-export function parseEarningsDate(raw: any): Date | null {
-  if (!raw?.raw) return null;
-  return new Date(raw.raw * 1000);
-}
-
-function rawNumber(value: any): number | null {
-  return typeof value?.raw === "number" ? value.raw : null;
-}
-
-function inferTiming(date: Date): "BMO" | "AMC" | "TNS" | "" {
-  const hour = date.getUTCHours();
-  if (hour >= 20) return "AMC";
-  if (hour <= 13) return "BMO";
-  return "";
-}
-
-export interface RawEarningsModules {
-  calendarEvents?: {
-    earnings?: {
-      earningsDate?: Array<{ raw: number }>;
-      earningsCallDate?: Array<{ raw: number }>;
-      isEarningsDateEstimate?: boolean;
-      earningsAverage?: { raw: number };
-      earningsLow?: { raw: number };
-      earningsHigh?: { raw: number };
-      revenueAverage?: { raw: number };
-      revenueLow?: { raw: number };
-      revenueHigh?: { raw: number };
-    };
-  };
-  earningsTrend?: {
-    trend?: Array<{
-      period: string;
-      earningsEstimate?: {
-        avg?: { raw: number };
-        low?: { raw: number };
-        high?: { raw: number };
-        yearAgoEps?: { raw: number };
-        numberOfAnalysts?: { raw: number };
-        growth?: { raw: number };
-      };
-      revenueEstimate?: {
-        avg?: { raw: number };
-        low?: { raw: number };
-        high?: { raw: number };
-        yearAgoRevenue?: { raw: number };
-        numberOfAnalysts?: { raw: number };
-        growth?: { raw: number };
-      };
-      epsTrend?: {
-        current?: { raw: number };
-        "7daysAgo"?: { raw: number };
-        "30daysAgo"?: { raw: number };
-      };
-      epsRevisions?: {
-        upLast7days?: { raw: number };
-        upLast30days?: { raw: number };
-        downLast7Days?: { raw: number };
-        downLast30days?: { raw: number };
-      };
-    }>;
-  };
-}
-
-export function parseEarningsModules(
-  symbol: string,
-  name: string,
-  modules: RawEarningsModules,
-): import("../../../types/data-provider").EarningsEvent | null {
-  const cal = modules?.calendarEvents;
-  if (!cal?.earnings) return null;
-
-  const dates = cal.earnings.earningsDate;
-  if (!Array.isArray(dates) || dates.length === 0) return null;
-
-  const earningsDate = parseEarningsDate(dates[0]);
-  if (!earningsDate) return null;
-
-  const currentQtr = modules?.earningsTrend?.trend?.find((t) => t.period === "0q");
-  const earningsEstimate = currentQtr?.earningsEstimate;
-  const revenueEstimate = currentQtr?.revenueEstimate;
-  const epsTrend = currentQtr?.epsTrend;
-  const epsRevisions = currentQtr?.epsRevisions;
-
-  return {
-    symbol,
-    name,
-    earningsDate,
-    earningsCallDate: parseEarningsDate(cal.earnings.earningsCallDate?.[0]) ?? null,
-    isDateEstimate: cal.earnings.isEarningsDateEstimate ?? null,
-    epsEstimate: rawNumber(earningsEstimate?.avg) ?? rawNumber(cal.earnings.earningsAverage),
-    epsLow: rawNumber(earningsEstimate?.low) ?? rawNumber(cal.earnings.earningsLow),
-    epsHigh: rawNumber(earningsEstimate?.high) ?? rawNumber(cal.earnings.earningsHigh),
-    epsYearAgo: rawNumber(earningsEstimate?.yearAgoEps),
-    epsGrowth: rawNumber(earningsEstimate?.growth),
-    epsAnalysts: rawNumber(earningsEstimate?.numberOfAnalysts),
-    epsTrend7dAgo: rawNumber(epsTrend?.["7daysAgo"]),
-    epsTrend30dAgo: rawNumber(epsTrend?.["30daysAgo"]),
-    epsRevisionUp7d: rawNumber(epsRevisions?.upLast7days),
-    epsRevisionUp30d: rawNumber(epsRevisions?.upLast30days),
-    epsRevisionDown7d: rawNumber(epsRevisions?.downLast7Days),
-    epsRevisionDown30d: rawNumber(epsRevisions?.downLast30days),
-    epsActual: null,
-    revenueEstimate: rawNumber(revenueEstimate?.avg) ?? rawNumber(cal.earnings.revenueAverage),
-    revenueLow: rawNumber(revenueEstimate?.low) ?? rawNumber(cal.earnings.revenueLow),
-    revenueHigh: rawNumber(revenueEstimate?.high) ?? rawNumber(cal.earnings.revenueHigh),
-    revenueYearAgo: rawNumber(revenueEstimate?.yearAgoRevenue),
-    revenueGrowth: rawNumber(revenueEstimate?.growth),
-    revenueAnalysts: rawNumber(revenueEstimate?.numberOfAnalysts),
-    revenueActual: null,
-    surprise: null,
-    timing: inferTiming(earningsDate),
-  };
-}

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

@@ -1,72 +0,0 @@
-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");
-  });
-});