gloomberb 0.2.0 → 0.3.1

package/src/plugins/builtin/portfolio-metrics.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from "bun:test";
+import type { CollectionSortPreference } from "../../state/app-context";
+import type { ColumnConfig } from "../../types/config";
+import type { TickerFinancials } from "../../types/financials";
+import type { TickerRecord } from "../../types/ticker";
+import {
+  calculatePortfolioSummaryTotals,
+  getColumnValue,
+  getSortValue,
+  resolveCollectionSortPreference,
+  resolvePortfolioPriceValue,
+  type ColumnContext,
+} from "./portfolio-list/metrics";
+
+function createTicker(overrides: Partial<TickerRecord["metadata"]> = {}): TickerRecord {
+  return {
+    metadata: {
+      ticker: "AAPL",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "Apple Inc.",
+      positions: [],
+      portfolios: [],
+      watchlists: [],
+      custom: {},
+      tags: [],
+      ...overrides,
+    },
+  };
+}
+
+function createFinancials(overrides: Partial<TickerFinancials> = {}): TickerFinancials {
+  return {
+    quote: {
+      symbol: "AAPL",
+      price: 120,
+      currency: "USD",
+      change: 5,
+      changePercent: 4.35,
+      previousClose: 115,
+      lastUpdated: 1_700_000_000_000,
+      ...overrides.quote,
+    },
+    annualStatements: [],
+    quarterlyStatements: [],
+    priceHistory: [],
+    ...overrides,
+  };
+}
+
+const defaultColumnContext: ColumnContext = {
+  activeTab: "main",
+  baseCurrency: "USD",
+  exchangeRates: new Map([["USD", 1]]),
+  now: 1_700_000_010_000,
+};
+
+describe("portfolio-metrics", () => {
+  test("defaults portfolio tabs to market value descending", () => {
+    expect(resolveCollectionSortPreference("main", true, {})).toEqual({
+      columnId: "mkt_value",
+      direction: "desc",
+    } satisfies CollectionSortPreference);
+  });
+
+  test("leaves watchlists unsorted by default and respects persisted overrides", () => {
+    expect(resolveCollectionSortPreference("watchlist", false, {})).toEqual({
+      columnId: null,
+      direction: "asc",
+    } satisfies CollectionSortPreference);
+    expect(resolveCollectionSortPreference("main", true, {
+      main: { columnId: "pnl", direction: "asc" },
+    })).toEqual({
+      columnId: "pnl",
+      direction: "asc",
+    } satisfies CollectionSortPreference);
+  });
+
+  test("shows broker mark price when no live quote is available", () => {
+    expect(resolvePortfolioPriceValue(null, 382.5)).toEqual({
+      text: "382.5",
+    });
+  });
+
+  test("calculates portfolio totals from live quotes", () => {
+    const ticker = createTicker({
+      positions: [{ portfolio: "main", shares: 10, avgCost: 100, broker: "manual" }],
+    });
+    const financialsMap = new Map([["AAPL", createFinancials()]]);
+
+    expect(calculatePortfolioSummaryTotals(
+      [ticker],
+      financialsMap,
+      "USD",
+      new Map([["USD", 1]]),
+      true,
+      "main",
+    )).toMatchObject({
+      totalMktValue: 1200,
+      totalCostBasis: 1000,
+      dailyPnl: 50,
+      unrealizedPnl: 200,
+      hasPositions: true,
+    });
+  });
+
+  test("falls back to broker values when no quote is available", () => {
+    const ticker = createTicker({
+      positions: [{
+        portfolio: "main",
+        shares: 10,
+        avgCost: 100,
+        broker: "ibkr",
+        marketValue: 1250,
+        unrealizedPnl: 250,
+      }],
+    });
+    const financialsMap = new Map<string, TickerFinancials>();
+
+    expect(calculatePortfolioSummaryTotals(
+      [ticker],
+      financialsMap,
+      "USD",
+      new Map([["USD", 1]]),
+      true,
+      "main",
+    )).toMatchObject({
+      totalMktValue: 1250,
+      totalCostBasis: 1000,
+      dailyPnl: 0,
+      unrealizedPnl: 250,
+      hasPositions: true,
+    });
+  });
+
+  test("formats portfolio-only column values and sort keys consistently", () => {
+    const ticker = createTicker({
+      positions: [{ portfolio: "main", shares: 10, avgCost: 100, broker: "manual" }],
+    });
+    const financials = createFinancials();
+    const pnlColumn: ColumnConfig = { id: "pnl", label: "P&L", width: 10, align: "right", format: "compact" };
+    const latencyColumn: ColumnConfig = { id: "latency", label: "AGE", width: 6, align: "right" };
+
+    expect(getColumnValue(pnlColumn, ticker, financials, defaultColumnContext)).toEqual({
+      text: "+200",
+      color: expect.any(String),
+    });
+    expect(getSortValue(pnlColumn, ticker, financials, defaultColumnContext)).toBe(200);
+    expect(getColumnValue(latencyColumn, ticker, financials, defaultColumnContext)).toEqual({
+      text: "10s",
+    });
+  });
+});

package/src/plugins/builtin/quote-monitor.test.tsx

@@ -0,0 +1,114 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import type { TickerFinancials } from "../../types/financials";
+import type { TickerRecord } from "../../types/ticker";
+import { createDefaultConfig } from "../../types/config";
+import { AppContext, createInitialState, PaneInstanceProvider } from "../../state/app-context";
+import { QuoteMonitorPane, tickerDetailPlugin } from "./ticker-detail";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy();
+    testSetup = undefined;
+  }
+});
+
+function createQuoteMonitorHarness() {
+  const config = createDefaultConfig("/tmp/gloomberb-test");
+  (config.layout as typeof config.layout & { docked: Array<{ instanceId: string; columnIndex: number; order: number }> }).docked = [
+    { instanceId: "ticker-detail:main", columnIndex: 0, order: 0 },
+    { instanceId: "quote-monitor:test", columnIndex: 1, order: 0 },
+  ];
+  config.layout.instances.push({
+    instanceId: "quote-monitor:test",
+    paneId: "quote-monitor",
+    title: "MSFT",
+    binding: { kind: "fixed", symbol: "MSFT" },
+  });
+
+  const state = createInitialState(config);
+
+  const ticker: TickerRecord = {
+    metadata: {
+      ticker: "MSFT",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "Microsoft",
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  };
+
+  const financials: TickerFinancials = {
+    quote: {
+      symbol: "MSFT",
+      price: 356.15,
+      currency: "USD",
+      change: -9.82,
+      changePercent: -2.68,
+      lastUpdated: Date.now(),
+    },
+    annualStatements: [],
+    quarterlyStatements: [],
+    priceHistory: [],
+  };
+
+  state.tickers = new Map([["MSFT", ticker]]);
+  state.financials = new Map([["MSFT", financials]]);
+
+  return (
+    <AppContext value={{ state, dispatch: () => {} }}>
+      <PaneInstanceProvider paneId="quote-monitor:test">
+        <QuoteMonitorPane paneId="quote-monitor:test" paneType="quote-monitor" focused width={72} height={7} />
+      </PaneInstanceProvider>
+    </AppContext>
+  );
+}
+
+describe("QuoteMonitorPane", () => {
+  test("renders a compact quote card for the bound ticker", async () => {
+    testSetup = await testRender(createQuoteMonitorHarness(), {
+      width: 72,
+      height: 7,
+    });
+
+    await testSetup.renderOnce();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("MSFT");
+    expect(frame).toContain("$356.15");
+    expect(frame).toContain("-2.68%");
+    expect(frame).toContain("-9.82");
+  });
+
+  test("registers a quote monitor pane template bound to the active ticker", () => {
+    const template = tickerDetailPlugin.paneTemplates?.find((entry) => entry.id === "quote-monitor-pane");
+
+    expect(template).toBeDefined();
+    expect(template?.label).toBe("Quote Monitor");
+    expect(template?.canCreate?.({
+      config: createDefaultConfig("/tmp/gloomberb-test"),
+      layout: createDefaultConfig("/tmp/gloomberb-test").layout,
+      focusedPaneId: "ticker-detail:main",
+      activeTicker: "MSFT",
+      activeCollectionId: null,
+    })).toBe(true);
+    expect(template?.createInstance?.({
+      config: createDefaultConfig("/tmp/gloomberb-test"),
+      layout: createDefaultConfig("/tmp/gloomberb-test").layout,
+      focusedPaneId: "ticker-detail:main",
+      activeTicker: "MSFT",
+      activeCollectionId: null,
+    })).toEqual({
+      title: "MSFT",
+      binding: { kind: "fixed", symbol: "MSFT" },
+      settings: { symbol: "MSFT" },
+      placement: "floating",
+    });
+  });
+});

package/src/plugins/builtin/sec.tsx

@@ -0,0 +1,250 @@
+import { useEffect, useRef, useState } from "react";
+import { useKeyboard } from "@opentui/react";
+import type { GloomPlugin, DetailTabProps } from "../../types/plugin";
+import type { SecFilingItem } from "../../types/data-provider";
+import { useResolvedEntryValue, useSecFilingContent, useSecFilingsQuery } from "../../market-data/hooks";
+import { instrumentFromTicker } from "../../market-data/request-types";
+import { usePluginPaneState } from "../../plugins/plugin-runtime";
+import { usePaneTicker } from "../../state/app-context";
+import { colors } from "../../theme/colors";
+import { Spinner } from "../../components/spinner";
+import { DetailFeedView, type DetailFeedItem } from "../../components/detail-feed-view";
+import { isUsEquityTicker } from "../../utils/sec";
+
+const SEC_FILING_LIMIT = 50;
+
+function getDisplayFormLabel(form: string): string {
+  const trimmed = form.trim();
+  return /^\d+(?:\/[A-Z])?$/i.test(trimmed)
+    ? `FORM ${trimmed}`
+    : trimmed;
+}
+
+function normalizeComparableText(value: string): string {
+  return value
+    .toUpperCase()
+    .replace(/\bFORM\b/g, "")
+    .replace(/[^A-Z0-9]+/g, "");
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function stripRedundantFormPrefix(form: string, description: string): string {
+  const pattern = escapeRegExp(form.trim()).replace(/\s+/g, "\\s+");
+  return description
+    .trim()
+    .replace(new RegExp(`^(?:FORM\\s+)?${pattern}(?:\\s*[:|-]\\s*|\\s+)`, "i"), "")
+    .trim();
+}
+
+function getMeaningfulPrimaryDescription(filing: SecFilingItem): string | undefined {
+  const description = filing.primaryDocDescription?.trim();
+  if (!description) return undefined;
+  if (normalizeComparableText(description) === normalizeComparableText(filing.form)) return undefined;
+
+  const stripped = stripRedundantFormPrefix(filing.form, description);
+  if (!stripped) return undefined;
+  if (normalizeComparableText(stripped) === normalizeComparableText(filing.form)) return undefined;
+  return stripped;
+}
+
+function getFilingDisplayTitle(filing: SecFilingItem): string {
+  const description = getMeaningfulPrimaryDescription(filing);
+  const formLabel = getDisplayFormLabel(filing.form);
+  return description ? `${formLabel} | ${description}` : formLabel;
+}
+
+function wrapMessageLines(text: string, width: number): string[] {
+  const maxWidth = Math.max(width, 12);
+  const words = text.trim().split(/\s+/);
+  const lines: string[] = [];
+  let current = "";
+
+  for (const word of words) {
+    if (!current) {
+      current = word;
+      continue;
+    }
+    if ((current.length + 1 + word.length) <= maxWidth) {
+      current = `${current} ${word}`;
+    } else {
+      lines.push(current);
+      current = word;
+    }
+  }
+
+  if (current) lines.push(current);
+  return lines;
+}
+
+function renderNotice(message: string, width: number) {
+  const lines = wrapMessageLines(message, width - 4);
+  return (
+    <box flexDirection="column" paddingX={1} paddingY={1}>
+      {lines.map((line, index) => (
+        <box key={index} height={1}>
+          <text fg={colors.textDim}>{line}</text>
+        </box>
+      ))}
+    </box>
+  );
+}
+
+function formatFiledAt(filing: SecFilingItem): string {
+  return filing.filingDate.toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+  });
+}
+
+function buildDetailBody(filing: SecFilingItem): string {
+  const sections = [
+    getMeaningfulPrimaryDescription(filing),
+    filing.items ? `Items: ${filing.items}` : undefined,
+    filing.primaryDocument ? `Primary document: ${filing.primaryDocument}` : undefined,
+  ].filter((value): value is string => !!value && value.trim().length > 0);
+
+  return sections.length > 0
+    ? sections.join("\n\n")
+    : "No additional SEC filing description is available for this entry.";
+}
+
+function toFeedItems(
+  filings: SecFilingItem[],
+  selectedAccessionNumber: string | undefined,
+  contentCache: Map<string, string | null>,
+  loadingContent: boolean,
+): DetailFeedItem[] {
+  return filings.map((filing) => {
+    const displayTitle = getFilingDisplayTitle(filing);
+    const hasFetchedContent = contentCache.has(filing.accessionNumber);
+    const fetchedContent = contentCache.get(filing.accessionNumber);
+    const fallbackBody = hasFetchedContent && !loadingContent && !fetchedContent
+      ? `${buildDetailBody(filing)}\n\nReadable filing content was not available for this document.`
+      : buildDetailBody(filing);
+
+    return {
+      id: filing.accessionNumber,
+      eyebrow: filing.form,
+      title: displayTitle,
+      timestamp: filing.filingDate,
+      preview: filing.items ? `Items ${filing.items}` : filing.primaryDocument,
+      detailTitle: displayTitle,
+      detailMeta: [
+        `Filed ${formatFiledAt(filing)}`,
+        `Accession ${filing.accessionNumber}`,
+        ...(filing.items ? [`Items ${filing.items}`] : []),
+        ...(filing.primaryDocument ? [`Primary document ${filing.primaryDocument}`] : []),
+      ],
+      detailBody: filing.accessionNumber === selectedAccessionNumber
+        ? (
+            loadingContent
+              ? "Loading filing content..."
+              : fetchedContent ?? fallbackBody
+          )
+        : fallbackBody,
+      detailNote: [filing.primaryDocumentUrl, filing.filingUrl].filter(Boolean).join("\n"),
+    };
+  });
+}
+
+function SecTab({ width, height, focused }: DetailTabProps) {
+  const { ticker } = usePaneTicker();
+  const selectionKey = `selectedIdx:${ticker?.metadata.ticker ?? "none"}`;
+  const [selectedIdx, setSelectedIdx] = usePluginPaneState<number>(selectionKey, 0);
+  const [hoveredIdx, setHoveredIdx] = useState<number | null>(null);
+  const [contentCache, setContentCache] = useState<Map<string, string | null>>(new Map());
+  const contentFetchRef = useRef(0);
+  const eligibleTicker = isUsEquityTicker(ticker);
+  const instrument = instrumentFromTicker(ticker, ticker?.metadata.ticker ?? null);
+  const filingsEntry = useSecFilingsQuery(
+    instrument && eligibleTicker
+      ? { instrument, count: SEC_FILING_LIMIT }
+      : null,
+  );
+  const filings = useResolvedEntryValue(filingsEntry) ?? [];
+  const loading = filingsEntry?.phase === "loading" || (filingsEntry?.phase === "refreshing" && filings.length === 0);
+  const error = filingsEntry?.phase === "error" ? filingsEntry.error?.message ?? "Failed to load SEC filings" : null;
+
+  useEffect(() => {
+    setHoveredIdx(null);
+    setContentCache(new Map());
+    contentFetchRef.current += 1;
+  }, [eligibleTicker, ticker?.metadata.exchange, ticker?.metadata.ticker]);
+
+  const selected = filings[selectedIdx];
+  const cachedSelectedContent = selected ? contentCache.get(selected.accessionNumber) : undefined;
+  const filingContentEntry = useSecFilingContent(
+    selected && cachedSelectedContent === undefined ? selected : null,
+  );
+  const filingContent = useResolvedEntryValue(filingContentEntry);
+  const loadingContent = filingContentEntry?.phase === "loading" || filingContentEntry?.phase === "refreshing";
+
+  useEffect(() => {
+    if (!selected) return;
+    if (cachedSelectedContent !== undefined) return;
+    if (filingContentEntry?.phase === "error") {
+      setContentCache((prev) => new Map(prev).set(selected.accessionNumber, null));
+      return;
+    }
+    if (filingContent !== null) {
+      setContentCache((prev) => new Map(prev).set(selected.accessionNumber, filingContent));
+    }
+  }, [cachedSelectedContent, filingContent, filingContentEntry?.phase, selected]);
+
+  useKeyboard((event) => {
+    if (!focused || filings.length === 0) return;
+    if (event.name === "j" || event.name === "down") {
+      setSelectedIdx((index) => Math.min(index + 1, filings.length - 1));
+    } else if (event.name === "k" || event.name === "up") {
+      setSelectedIdx((index) => Math.max(index - 1, 0));
+    }
+  });
+
+  useEffect(() => {
+    if (filings.length > 0 && selectedIdx >= filings.length) {
+      setSelectedIdx(Math.max(0, filings.length - 1));
+    }
+  }, [filings.length, selectedIdx, setSelectedIdx]);
+
+  if (!ticker) return <text fg={colors.textDim}>Select a ticker to view SEC filings.</text>;
+  if (!eligibleTicker) return renderNotice("SEC filings are only shown for US equities.", width);
+  if (loading && filings.length === 0) return <Spinner label="Loading SEC filings..." />;
+  if (error) return renderNotice(`Error: ${error}`, width);
+  if (filings.length === 0) return renderNotice(`No recent SEC filings for ${ticker.metadata.ticker}.`, width);
+
+  return (
+    <DetailFeedView
+      width={width}
+      height={height}
+      items={toFeedItems(filings, selected?.accessionNumber, contentCache, loadingContent)}
+      selectedIdx={selectedIdx}
+      hoveredIdx={hoveredIdx}
+      onSelect={setSelectedIdx}
+      onHover={setHoveredIdx}
+      listVariant="single-line"
+      splitListWidthRatio={0.33}
+    />
+  );
+}
+
+export const secPlugin: GloomPlugin = {
+  id: "sec",
+  name: "SEC",
+  version: "1.0.0",
+  description: "Recent SEC filings for US equities",
+  toggleable: true,
+
+  setup(ctx) {
+    ctx.registerDetailTab({
+      id: "sec",
+      name: "SEC",
+      order: 45,
+      component: SecTab,
+      isVisible: ({ ticker }) => isUsEquityTicker(ticker),
+    });
+  },
+};

package/src/plugins/builtin/ticker-detail/chart-tab.tsx

@@ -0,0 +1,43 @@
+import { useTerminalDimensions } from "@opentui/react";
+import type { ChartAxisMode } from "../../../components/chart/chart-types";
+import { StockChart } from "../../../components/chart/stock-chart";
+
+export function ChartTab({
+  width,
+  height,
+  focused,
+  interactive,
+  axisMode,
+  onActivate,
+}: {
+  width?: number;
+  height?: number;
+  focused: boolean;
+  interactive: boolean;
+  axisMode: ChartAxisMode;
+  onActivate?: () => void;
+}) {
+  const { width: termWidth, height: termHeight } = useTerminalDimensions();
+
+  const chartWidth = Math.max((width || Math.floor(termWidth * 0.55)) - 2, 30);
+  const chartHeight = Math.max((height || termHeight - 8) - 2, 10);
+
+  return (
+    <box
+      flexDirection="column"
+      paddingX={1}
+      flexGrow={1}
+      onMouseDown={() => {
+        if (!interactive) onActivate?.();
+      }}
+    >
+      <StockChart
+        width={chartWidth}
+        height={chartHeight}
+        focused={focused}
+        interactive={interactive}
+        axisMode={axisMode}
+      />
+    </box>
+  );
+}