gloomberb 0.5.1 → 0.6.0

package/src/plugins/builtin/debug.tsx

@@ -1,9 +1,13 @@
+import { Box, Text } from "../../ui";
 import { useState, useEffect, useCallback, useRef } from "react";
-import { useKeyboard } from "@opentui/react";
-import { TextAttributes } from "@opentui/core";
+import { useShortcut } from "../../react/input";
+import { TextAttributes } from "../../ui";
 import type { GloomPlugin, PaneProps } from "../../types/plugin";
+import { usePaneFooter } from "../../components";
+import { usePluginAppActions } from "../plugin-runtime";
 import { colors, hoverBg } from "../../theme/colors";
 import { debugLog, type LogEntry, type LogLevel } from "../../utils/debug-log";
+import { wrapTextLines } from "../../utils/text-wrap";
 import { writeFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -53,6 +57,7 @@ function formatTimestamp(ts: number): string {
 }
 
 function DebugPane({ focused, width, height }: PaneProps) {
+  const { notify } = usePluginAppActions();
   const [entries, setEntries] = useState<LogEntry[]>(() => debugLog.getEntries());
   const [filterLevel, setFilterLevel] = useState<LogLevel | null>(null);
   const [filterSource, setFilterSource] = useState<string | null>(null);
@@ -79,37 +84,50 @@ function DebugPane({ focused, width, height }: PaneProps) {
 
   const exportLogs = useCallback(() => {
     const result = exportDebugLogFile({ filterLevel, filterSource });
-    const registry = (globalThis as any).__gloomRegistry;
     if (result.ok) {
-      registry?.notify?.({ body: `Exported to ~/Downloads/${result.filename}`, type: "success" });
+      notify({ body: `Exported to ~/Downloads/${result.filename}`, type: "success" });
       return;
     }
-    registry?.notify?.({ body: "Failed to export logs", type: "error" });
-  }, [filterLevel, filterSource]);
+    notify({ body: "Failed to export logs", type: "error" });
+  }, [filterLevel, filterSource, notify]);
 
   const clearLogs = useCallback(() => {
     debugLog.clear();
     setEntries([]);
   }, []);
+  const cycleLevelFilter = useCallback(() => {
+    const currentIdx = filterLevel ? ALL_LEVELS.indexOf(filterLevel) : -1;
+    const nextIdx = currentIdx + 1;
+    setFilterLevel(nextIdx >= ALL_LEVELS.length ? null : ALL_LEVELS[nextIdx] ?? null);
+  }, [filterLevel]);
+  const cycleSourceFilter = useCallback(() => {
+    const sources = sourcesRef.current;
+    if (sources.length === 0) return;
+    const currentIdx = filterSource ? sources.indexOf(filterSource) : -1;
+    const nextIdx = currentIdx + 1;
+    setFilterSource(nextIdx >= sources.length ? null : sources[nextIdx] ?? null);
+  }, [filterSource]);
+  const jumpTop = useCallback(() => {
+    setSelectedIdx(0);
+    setAutoScroll(false);
+  }, []);
+  const jumpBottom = useCallback(() => {
+    setSelectedIdx(entries.length - 1);
+    setAutoScroll(true);
+  }, [entries.length]);
 
-  useKeyboard((event) => {
+  useShortcut((event) => {
     if (!focused) return;
 
     // Level filter cycling
     if (event.name === "l") {
-      const currentIdx = filterLevel ? ALL_LEVELS.indexOf(filterLevel) : -1;
-      const nextIdx = currentIdx + 1;
-      setFilterLevel(nextIdx >= ALL_LEVELS.length ? null : ALL_LEVELS[nextIdx] ?? null);
+      cycleLevelFilter();
       return;
     }
 
     // Source filter cycling
     if (event.name === "s") {
-      const sources = sourcesRef.current;
-      if (sources.length === 0) return;
-      const currentIdx = filterSource ? sources.indexOf(filterSource) : -1;
-      const nextIdx = currentIdx + 1;
-      setFilterSource(nextIdx >= sources.length ? null : sources[nextIdx] ?? null);
+      cycleSourceFilter();
       return;
     }
 
@@ -150,13 +168,11 @@ function DebugPane({ focused, width, height }: PaneProps) {
     }
 
     if (event.name === "g" && !event.shift) {
-      setSelectedIdx(0);
-      setAutoScroll(false);
+      jumpTop();
       return;
     }
     if (event.name === "g" && event.shift) {
-      setSelectedIdx(entries.length - 1);
-      setAutoScroll(true);
+      jumpBottom();
       return;
     }
 
@@ -166,9 +182,8 @@ function DebugPane({ focused, width, height }: PaneProps) {
     }
   });
 
-  const headerHeight = 2;
   const contentWidth = Math.max(1, width - 2);
-  const messageAreaHeight = Math.max(1, height - headerHeight);
+  const messageAreaHeight = Math.max(1, height);
 
   // Compute visible window
   const visibleCount = showDetail ? Math.max(1, messageAreaHeight - 4) : messageAreaHeight;
@@ -189,32 +204,42 @@ function DebugPane({ focused, width, height }: PaneProps) {
   const visibleEntries = entries.slice(viewStart, viewStart + visibleCount);
 
   const selectedEntry = selectedIdx >= 0 && selectedIdx < entries.length ? entries[selectedIdx] : null;
+  const detailTextWidth = Math.max(1, contentWidth - 2);
+  const detailMessageLines = selectedEntry
+    ? wrapTextLines(
+        selectedEntry.message,
+        detailTextWidth,
+        selectedEntry.data === undefined ? 3 : 2,
+      )
+    : [];
+  const detailDataLines = selectedEntry?.data === undefined
+    ? []
+    : wrapTextLines(
+        JSON.stringify(selectedEntry.data, null, 2),
+        detailTextWidth,
+        Math.max(1, 3 - detailMessageLines.length),
+      );
 
-  return (
-    <box flexDirection="column" width={width} height={height}>
-      {/* Header */}
-      <box height={1} width={contentWidth} flexDirection="row" paddingLeft={1}>
-        <text fg={colors.textBright} attributes={TextAttributes.BOLD}>Debug Log</text>
-        <text fg={colors.textDim}> ({totalEntries})</text>
-        <box flexGrow={1} />
-        {filterLevel && (
-          <text fg={levelColor(filterLevel)} attributes={TextAttributes.BOLD}>
-            {" "}{filterLevel.toUpperCase()}{" "}
-          </text>
-        )}
-        {filterSource && (
-          <text fg={colors.positive}>
-            {" "}{filterSource}{" "}
-          </text>
-        )}
-        {autoScroll && <text fg={colors.textDim}> AUTO </text>}
-      </box>
-      <box height={1} width={contentWidth}>
-        <text fg={colors.border}>{"-".repeat(contentWidth)}</text>
-      </box>
+  usePaneFooter("debug-log", () => ({
+    info: [
+      ...(filterLevel ? [{ id: "level", parts: [{ text: filterLevel.toUpperCase(), tone: "value" as const, color: levelColor(filterLevel), bold: true }] }] : []),
+      ...(filterSource ? [{ id: "source", parts: [{ text: filterSource, tone: "positive" as const }] }] : []),
+      ...(autoScroll ? [{ id: "auto", parts: [{ text: "AUTO", tone: "muted" as const }] }] : []),
+    ],
+    hints: [
+      { id: "level", key: "l", label: "evel", onPress: cycleLevelFilter },
+      { id: "source", key: "s", label: "ource", onPress: cycleSourceFilter },
+      { id: "export", key: "e", label: "xport", onPress: exportLogs },
+      { id: "clear", key: "x", label: "clear", onPress: clearLogs },
+      { id: "auto", key: "a", label: "uto", onPress: () => setAutoScroll((prev) => !prev) },
+      { id: "jump", key: "g/G", label: "jump", onPress: jumpBottom },
+    ],
+  }), [autoScroll, clearLogs, cycleLevelFilter, cycleSourceFilter, exportLogs, filterLevel, filterSource, jumpBottom]);
 
+  return (
+    <Box flexDirection="column" width={width} height={height}>
       {/* Log entries */}
-      <box
+      <Box
         height={visibleCount}
         flexDirection="column"
         onMouseScroll={(event: any) => {
@@ -230,9 +255,9 @@ function DebugPane({ focused, width, height }: PaneProps) {
         }}
       >
         {visibleEntries.length === 0 && (
-          <box alignItems="center" justifyContent="center" flexGrow={1}>
-            <text fg={colors.textDim}>No log entries{filterLevel || filterSource ? " matching filter" : ""}</text>
-          </box>
+          <Box alignItems="center" justifyContent="center" flexGrow={1}>
+            <Text fg={colors.textDim}>No log entries{filterLevel || filterSource ? " matching filter" : ""}</Text>
+          </Box>
         )}
         {visibleEntries.map((entry, i) => {
           const globalIdx = viewStart + i;
@@ -248,43 +273,47 @@ function DebugPane({ focused, width, height }: PaneProps) {
             : entry.message;
 
           return (
-            <box
+            <Box
               key={entry.id}
               height={1}
               width={contentWidth}
               flexDirection="row"
               backgroundColor={bgColor}
-              onMouseMove={() => setHoveredIdx(globalIdx)}
+              onMouseMove={() => setHoveredIdx((current) => (current === globalIdx ? current : globalIdx))}
               onMouseDown={() => { setSelectedIdx(globalIdx); setAutoScroll(false); }}
             >
-              <text fg={colors.textMuted}> {ts} </text>
-              <text fg={levelColor(entry.level)} attributes={TextAttributes.BOLD}>{lvl}</text>
-              <text fg={colors.textDim}> [{sourceTag}] </text>
-              <text fg={isSelected ? colors.selectedText ?? colors.textBright : colors.text}>
+              <Text fg={colors.textMuted}> {ts} </Text>
+              <Text fg={levelColor(entry.level)} attributes={TextAttributes.BOLD}>{lvl}</Text>
+              <Text fg={colors.textDim}> [{sourceTag}] </Text>
+              <Text fg={isSelected ? colors.selectedText ?? colors.textBright : colors.text}>
                 {msg}
-              </text>
-            </box>
+              </Text>
+            </Box>
           );
         })}
-      </box>
+      </Box>
 
       {/* Detail panel */}
       {showDetail && selectedEntry && (
-        <box flexDirection="column" height={4} width={contentWidth}>
-          <box height={1} width={contentWidth}>
-            <text fg={colors.border}>{"-".repeat(contentWidth)}</text>
-          </box>
-          <box paddingLeft={1} flexDirection="column">
-            <text fg={colors.text}>{selectedEntry.message}</text>
-            {selectedEntry.data !== undefined && (
-              <text fg={colors.textDim}>
-                {JSON.stringify(selectedEntry.data, null, 2).slice(0, contentWidth * 2)}
-              </text>
-            )}
-          </box>
-        </box>
+        <Box flexDirection="column" height={4} width={contentWidth}>
+          <Box height={1} width={contentWidth}>
+            <Text fg={colors.border}>{"-".repeat(contentWidth)}</Text>
+          </Box>
+          <Box paddingLeft={1} flexDirection="column">
+            {detailMessageLines.map((line, index) => (
+              <Box key={`message:${index}`} height={1}>
+                <Text fg={colors.text}>{line || " "}</Text>
+              </Box>
+            ))}
+            {detailDataLines.map((line, index) => (
+              <Box key={`data:${index}`} height={1}>
+                <Text fg={colors.textDim}>{line || " "}</Text>
+              </Box>
+            ))}
+          </Box>
+        </Box>
       )}
-    </box>
+    </Box>
   );
 }
 

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

@@ -77,7 +77,7 @@ class MemoryPluginPersistence implements PluginPersistence {
     kind: string,
     key: string,
     value: T,
-    options: { sourceKey?: string; stale?: boolean; expired?: boolean } = {},
+    options: { sourceKey?: string; stale?: boolean; expired?: boolean; schemaVersion?: number } = {},
   ): void {
     const now = Date.now();
     const record: PersistedResourceValue<T> = {
@@ -86,7 +86,7 @@ class MemoryPluginPersistence implements PluginPersistence {
       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,
+      schemaVersion: options.schemaVersion ?? 2,
       stale: !!options.stale,
       expired: !!options.expired,
     };

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

@@ -4,7 +4,7 @@ import type { PluginPersistence } from "../../../types/plugin";
 
 const CACHE_KIND = "calendar";
 const CACHE_SOURCE = "earnings";
-const CACHE_SCHEMA_VERSION = 1;
+const CACHE_SCHEMA_VERSION = 2;
 
 export const EARNINGS_CALENDAR_CACHE_POLICY = {
   staleMs: 30 * 60 * 1000,
@@ -16,8 +16,9 @@ interface MemoryCacheEntry {
   fetchedAt: number;
 }
 
-type PersistedEarningsEvent = Omit<EarningsEvent, "earningsDate"> & {
+type PersistedEarningsEvent = Omit<EarningsEvent, "earningsDate" | "earningsCallDate"> & {
   earningsDate: string;
+  earningsCallDate?: string | null;
 };
 
 let earningsPersistence: PluginPersistence | null = null;
@@ -53,6 +54,7 @@ function serializeEvents(events: EarningsEvent[]): PersistedEarningsEvent[] {
   return events.map((event) => ({
     ...event,
     earningsDate: event.earningsDate.toISOString(),
+    earningsCallDate: event.earningsCallDate?.toISOString() ?? null,
   }));
 }
 
@@ -61,8 +63,15 @@ function deserializeEvents(events: PersistedEarningsEvent[]): EarningsEvent[] {
     .map((event) => ({
       ...event,
       earningsDate: new Date(event.earningsDate),
+      earningsCallDate: event.earningsCallDate ? new Date(event.earningsCallDate) : null,
     }))
-    .filter((event) => !Number.isNaN(event.earningsDate.getTime()));
+    .filter((event) => (
+      !Number.isNaN(event.earningsDate.getTime())
+      && (
+        !event.earningsCallDate
+        || !Number.isNaN(event.earningsCallDate.getTime())
+      )
+    ));
 }
 
 function readPersistedCache(

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

@@ -7,11 +7,6 @@ describe("parseEarningsDate", () => {
     expect(d).toBeInstanceOf(Date);
     expect(d!.getFullYear()).toBeGreaterThanOrEqual(2024);
   });
-
-  test("returns null for missing data", () => {
-    expect(parseEarningsDate(null)).toBeNull();
-    expect(parseEarningsDate({})).toBeNull();
-  });
 });
 
 describe("parseEarningsModules", () => {
@@ -20,8 +15,14 @@ describe("parseEarningsModules", () => {
       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: [] },
@@ -29,6 +30,10 @@ describe("parseEarningsModules", () => {
     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);
   });
 
@@ -43,17 +48,43 @@ describe("parseEarningsModules", () => {
       earningsTrend: {
         trend: [{
           period: "0q",
-          earningsEstimate: { avg: { raw: 1.55 } },
-          revenueEstimate: { avg: { raw: 91000000000 } },
+          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);
   });
 
-  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

@@ -1,21 +1,64 @@
+
 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 } };
-      revenueEstimate?: { avg?: { raw: number } };
+      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 };
+      };
     }>;
   };
 }
@@ -35,16 +78,38 @@ export function parseEarningsModules(
   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,
-    epsEstimate: currentQtr?.earningsEstimate?.avg?.raw ?? cal.earnings.earningsAverage?.raw ?? null,
+    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: currentQtr?.revenueEstimate?.avg?.raw ?? cal.earnings.revenueAverage?.raw ?? 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: "",
+    timing: inferTiming(earningsDate),
   };
 }