gloomberb 0.4.1 → 0.5.1

package/src/plugins/builtin/debug.tsx

@@ -2,13 +2,33 @@ import { useState, useEffect, useCallback, useRef } from "react";
 import { useKeyboard } from "@opentui/react";
 import { TextAttributes } from "@opentui/core";
 import type { GloomPlugin, PaneProps } from "../../types/plugin";
-import { useAppState } from "../../state/app-context";
 import { colors, hoverBg } from "../../theme/colors";
 import { debugLog, type LogEntry, type LogLevel } from "../../utils/debug-log";
 import { writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 
+function exportDebugLogFile(options: {
+  filterLevel?: LogLevel | null;
+  filterSource?: string | null;
+}): { ok: true; filename: string } | { ok: false } {
+  const text = debugLog.exportAsText(
+    options.filterLevel || options.filterSource
+      ? { level: options.filterLevel ?? undefined, source: options.filterSource ?? undefined }
+      : undefined,
+  );
+  const downloadsDir = join(homedir(), "Downloads");
+  const filename = `gloomberb-debug-${new Date().toISOString().slice(0, 19).replace(/:/g, "-")}.log`;
+  const filepath = join(downloadsDir, filename);
+
+  try {
+    writeFileSync(filepath, text);
+    return { ok: true, filename };
+  } catch {
+    return { ok: false };
+  }
+}
+
 function levelColor(level: LogLevel): string {
   switch (level) {
     case "debug": return colors.textDim;
@@ -32,8 +52,7 @@ function formatTimestamp(ts: number): string {
   return d.toISOString().slice(11, 23);
 }
 
-function DebugPane({ focused, width, height, close }: PaneProps) {
-  const { dispatch } = useAppState();
+function DebugPane({ focused, width, height }: PaneProps) {
   const [entries, setEntries] = useState<LogEntry[]>(() => debugLog.getEntries());
   const [filterLevel, setFilterLevel] = useState<LogLevel | null>(null);
   const [filterSource, setFilterSource] = useState<string | null>(null);
@@ -59,22 +78,13 @@ function DebugPane({ focused, width, height, close }: PaneProps) {
   }, [filterLevel, filterSource, autoScroll]);
 
   const exportLogs = useCallback(() => {
-    const text = debugLog.exportAsText(
-      filterLevel || filterSource
-        ? { level: filterLevel ?? undefined, source: filterSource ?? undefined }
-        : undefined,
-    );
-    const downloadsDir = join(homedir(), "Downloads");
-    const filename = `gloomberb-debug-${new Date().toISOString().slice(0, 19).replace(/:/g, "-")}.log`;
-    const filepath = join(downloadsDir, filename);
-    try {
-      writeFileSync(filepath, text);
-      const registry = (globalThis as any).__gloomRegistry;
-      registry?.showToastFn?.(`Exported to ~/Downloads/${filename}`, { type: "success" });
-    } catch {
-      const registry = (globalThis as any).__gloomRegistry;
-      registry?.showToastFn?.("Failed to export logs", { type: "error" });
+    const result = exportDebugLogFile({ filterLevel, filterSource });
+    const registry = (globalThis as any).__gloomRegistry;
+    if (result.ok) {
+      registry?.notify?.({ body: `Exported to ~/Downloads/${result.filename}`, type: "success" });
+      return;
     }
+    registry?.notify?.({ body: "Failed to export logs", type: "error" });
   }, [filterLevel, filterSource]);
 
   const clearLogs = useCallback(() => {
@@ -150,20 +160,15 @@ function DebugPane({ focused, width, height, close }: PaneProps) {
       return;
     }
 
-    if (event.name === "escape") {
-      if (showDetail) {
-        setShowDetail(false);
-      } else {
-        close?.();
-      }
+    if (event.name === "escape" && showDetail) {
+      setShowDetail(false);
       return;
     }
   });
 
   const headerHeight = 2;
-  const footerHeight = 1;
   const contentWidth = Math.max(1, width - 2);
-  const messageAreaHeight = Math.max(1, height - headerHeight - footerHeight);
+  const messageAreaHeight = Math.max(1, height - headerHeight);
 
   // Compute visible window
   const visibleCount = showDetail ? Math.max(1, messageAreaHeight - 4) : messageAreaHeight;
@@ -279,21 +284,6 @@ function DebugPane({ focused, width, height, close }: PaneProps) {
           </box>
         </box>
       )}
-
-      {/* Footer */}
-      <box height={1} width={contentWidth} flexDirection="row" paddingLeft={1}>
-        <text fg={colors.textMuted}>
-          <span fg={colors.text}>l</span>evel
-          {"  "}
-          <span fg={colors.text}>s</span>ource
-          {"  "}
-          <span fg={colors.text}>e</span>xport
-          {"  "}
-          <span fg={colors.text}>x</span> clear
-          {"  "}
-          <span fg={colors.text}>a</span>uto-scroll
-        </text>
-      </box>
     </box>
   );
 }
@@ -334,15 +324,11 @@ export const debugPlugin: GloomPlugin = {
       keywords: ["export", "debug", "log", "download", "save"],
       category: "config",
       execute: () => {
-        const text = debugLog.exportAsText();
-        const downloadsDir = join(homedir(), "Downloads");
-        const filename = `gloomberb-debug-${new Date().toISOString().slice(0, 19).replace(/:/g, "-")}.log`;
-        const filepath = join(downloadsDir, filename);
-        try {
-          writeFileSync(filepath, text);
-          ctx.showToast(`Exported to ~/Downloads/${filename}`, { type: "success" });
-        } catch {
-          ctx.showToast("Failed to export logs", { type: "error" });
+        const result = exportDebugLogFile({});
+        if (result.ok) {
+          ctx.notify({ body: `Exported to ~/Downloads/${result.filename}`, type: "success" });
+        } else {
+          ctx.notify({ body: "Failed to export logs", type: "error" });
         }
       },
     });

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

@@ -0,0 +1,181 @@
+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 } = {},
+  ): 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: 1,
+      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

@@ -0,0 +1,136 @@
+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 = 1;
+
+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"> & {
+  earningsDate: string;
+};
+
+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(),
+  }));
+}
+
+function deserializeEvents(events: PersistedEarningsEvent[]): EarningsEvent[] {
+  return events
+    .map((event) => ({
+      ...event,
+      earningsDate: new Date(event.earningsDate),
+    }))
+    .filter((event) => !Number.isNaN(event.earningsDate.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

@@ -0,0 +1,59 @@
+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);
+  });
+
+  test("returns null for missing data", () => {
+    expect(parseEarningsDate(null)).toBeNull();
+    expect(parseEarningsDate({})).toBeNull();
+  });
+});
+
+describe("parseEarningsModules", () => {
+  test("extracts earnings date and estimates", () => {
+    const result = parseEarningsModules("AAPL", "Apple Inc.", {
+      calendarEvents: {
+        earnings: {
+          earningsDate: [{ raw: 1714521600 }],
+          earningsAverage: { raw: 1.53 },
+          revenueAverage: { raw: 90500000000 },
+        },
+      },
+      earningsTrend: { trend: [] },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.symbol).toBe("AAPL");
+    expect(result!.epsEstimate).toBe(1.53);
+    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 } },
+          revenueEstimate: { avg: { raw: 91000000000 } },
+        }],
+      },
+    });
+    expect(result!.epsEstimate).toBe(1.55);
+    expect(result!.revenueEstimate).toBe(91000000000);
+  });
+
+  test("returns null when no earnings data", () => {
+    expect(parseEarningsModules("XYZ", "XYZ", {})).toBeNull();
+    expect(parseEarningsModules("XYZ", "XYZ", { calendarEvents: {} })).toBeNull();
+  });
+});

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

@@ -0,0 +1,50 @@
+export function parseEarningsDate(raw: any): Date | null {
+  if (!raw?.raw) return null;
+  return new Date(raw.raw * 1000);
+}
+
+export interface RawEarningsModules {
+  calendarEvents?: {
+    earnings?: {
+      earningsDate?: Array<{ raw: number }>;
+      earningsAverage?: { raw: number };
+      revenueAverage?: { raw: number };
+    };
+  };
+  earningsTrend?: {
+    trend?: Array<{
+      period: string;
+      earningsEstimate?: { avg?: { raw: number } };
+      revenueEstimate?: { avg?: { 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");
+
+  return {
+    symbol,
+    name,
+    earningsDate,
+    epsEstimate: currentQtr?.earningsEstimate?.avg?.raw ?? cal.earnings.earningsAverage?.raw ?? null,
+    epsActual: null,
+    revenueEstimate: currentQtr?.revenueEstimate?.avg?.raw ?? cal.earnings.revenueAverage?.raw ?? null,
+    revenueActual: null,
+    surprise: null,
+    timing: "",
+  };
+}