gloomberb 0.1.0 → 0.3.1

package/src/plugins/builtin/comparison-chart.test.tsx

@@ -0,0 +1,277 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "@opentui/react/test-utils";
+import {
+  AppContext,
+  createInitialState,
+  PaneInstanceProvider,
+} from "../../state/app-context";
+import { cloneLayout, createDefaultConfig } from "../../types/config";
+import type { DataProvider } from "../../types/data-provider";
+import type { TickerFinancials } from "../../types/financials";
+import type { PluginRegistry } from "../../plugins/registry";
+import { setSharedDataProviderForTests, setSharedRegistryForTests } from "../../plugins/registry";
+import type { TickerRecord } from "../../types/ticker";
+import {
+  buildComparisonChartPaneTitle,
+  comparisonChartPlugin,
+  COMPARISON_CHART_PANE_ID,
+  COMPARISON_CHART_TEMPLATE_ID,
+  getComparisonChartPaneSettings,
+} from "./comparison-chart";
+
+const TEST_PANE_ID = "comparison-chart:test";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+function makeTicker(symbol: string, currency: string): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange: "NASDAQ",
+      currency,
+      name: symbol,
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+function makeFinancials(symbol: string, currency: string, closes: number[]): TickerFinancials {
+  return {
+    annualStatements: [],
+    quarterlyStatements: [],
+    quote: {
+      symbol,
+      price: closes[closes.length - 1] ?? 0,
+      currency,
+      change: (closes[closes.length - 1] ?? 0) - (closes[0] ?? 0),
+      changePercent: closes[0] ? (((closes[closes.length - 1] ?? 0) - closes[0]!) / closes[0]!) * 100 : 0,
+      lastUpdated: Date.now(),
+    },
+    priceHistory: closes.map((close, index) => ({
+      date: new Date(2024, 0, index + 2),
+      close,
+    })),
+  };
+}
+
+function createProvider(historyBySymbol: Record<string, number[]>, currencyBySymbol: Record<string, string>): DataProvider {
+  return {
+    id: "test-provider",
+    name: "Test Provider",
+    getTickerFinancials: async (symbol) => makeFinancials(symbol, currencyBySymbol[symbol] ?? "USD", historyBySymbol[symbol] ?? []),
+    getQuote: async (symbol) => ({
+      symbol,
+      price: historyBySymbol[symbol]?.[historyBySymbol[symbol]!.length - 1] ?? 0,
+      currency: currencyBySymbol[symbol] ?? "USD",
+      change: 0,
+      changePercent: 0,
+      lastUpdated: Date.now(),
+    }),
+    getExchangeRate: async () => 1,
+    search: async () => [],
+    getNews: async () => [],
+    getArticleSummary: async () => null,
+    getPriceHistory: async (symbol) => (
+      historyBySymbol[symbol] ?? []
+    ).map((close, index) => ({
+      date: new Date(2024, 0, index + 2),
+      close,
+    })),
+  };
+}
+
+function createRegistrySpy(spy: { selected: string[]; focused: string[] }): PluginRegistry {
+  return {
+    selectTickerFn: (symbol: string) => { spy.selected.push(symbol); },
+    focusPaneFn: (paneId: string) => { spy.focused.push(paneId); },
+  } as unknown as PluginRegistry;
+}
+
+function createComparisonHarness(
+  settings: Record<string, unknown>,
+  tickers: TickerRecord[],
+  financials: Array<[string, TickerFinancials]>,
+) {
+  const config = createDefaultConfig("/tmp/gloomberb-compare");
+  const layout = {
+    dockRoot: { kind: "pane" as const, instanceId: TEST_PANE_ID },
+    instances: [{
+      instanceId: TEST_PANE_ID,
+      paneId: "comparison-chart",
+      settings,
+    }],
+    floating: [],
+  };
+  const nextConfig = {
+    ...config,
+    layout,
+    layouts: [{ name: "Default", layout: cloneLayout(layout) }],
+  };
+  const state = createInitialState(nextConfig);
+  state.focusedPaneId = TEST_PANE_ID;
+  state.tickers = new Map(tickers.map((ticker) => [ticker.metadata.ticker, ticker]));
+  state.financials = new Map(financials);
+
+  const ComparisonPane = comparisonChartPlugin.panes?.[0]?.component as (props: {
+    paneId: string;
+    paneType: string;
+    focused: boolean;
+    width: number;
+    height: number;
+  }) => JSX.Element;
+
+  return (
+    <AppContext value={{ state, dispatch: () => {} }}>
+      <PaneInstanceProvider paneId={TEST_PANE_ID}>
+        <ComparisonPane
+          paneId={TEST_PANE_ID}
+          paneType="comparison-chart"
+          focused
+          width={120}
+          height={20}
+        />
+      </PaneInstanceProvider>
+    </AppContext>
+  );
+}
+
+async function flushFrames(count = 3) {
+  for (let index = 0; index < count; index += 1) {
+    await act(async () => {
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+  }
+}
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy();
+    testSetup = undefined;
+  }
+  setSharedRegistryForTests(undefined);
+  setSharedDataProviderForTests(undefined);
+});
+
+describe("comparisonChartPlugin", () => {
+  test("creates a configured comparison pane with percent as the default axis", () => {
+    const template = comparisonChartPlugin.paneTemplates?.find((entry) => entry.id === COMPARISON_CHART_TEMPLATE_ID);
+    const paneDef = comparisonChartPlugin.panes.find((entry) => entry.id === COMPARISON_CHART_PANE_ID);
+
+    expect(template).toBeDefined();
+    expect(paneDef?.defaultMode).toBe("floating");
+    expect(template?.createInstance?.({
+      config: createDefaultConfig("/tmp/gloomberb-compare"),
+      layout: createDefaultConfig("/tmp/gloomberb-compare").layout,
+      focusedPaneId: "ticker-detail:main",
+      activeTicker: null,
+      activeCollectionId: null,
+    }, {
+      symbols: ["AAPL", "MSFT", "NVDA"],
+    })).toEqual({
+      placement: "floating",
+      title: "AAPL · MSFT · NVDA",
+      settings: {
+        axisMode: "percent",
+        symbols: ["AAPL", "MSFT", "NVDA"],
+        symbolsText: "AAPL, MSFT, NVDA",
+      },
+    });
+  });
+
+  test("parses stored pane settings and backfills the text form", () => {
+    expect(getComparisonChartPaneSettings({
+      axisMode: "percent",
+      symbols: ["AAPL", "MSFT"],
+    })).toEqual({
+      axisMode: "percent",
+      symbols: ["AAPL", "MSFT"],
+      symbolsText: "AAPL, MSFT",
+    });
+  });
+
+  test("renders one shared overlay chart with the mixed-currency warning", async () => {
+    setSharedDataProviderForTests(createProvider({
+      AAPL: [100, 102, 104, 106],
+      "7203": [2000, 2020, 2050, 2100],
+    }, {
+      AAPL: "USD",
+      "7203": "JPY",
+    }));
+    setSharedRegistryForTests(createRegistrySpy({ selected: [], focused: [] }));
+
+    testSetup = await testRender(
+      createComparisonHarness({
+        axisMode: "price",
+        symbols: ["AAPL", "7203"],
+        symbolsText: "AAPL, 7203",
+      }, [
+        makeTicker("AAPL", "USD"),
+        makeTicker("7203", "JPY"),
+      ], [
+        ["AAPL", makeFinancials("AAPL", "USD", [100, 102, 104, 106])],
+        ["7203", makeFinancials("7203", "JPY", [2000, 2020, 2050, 2100])],
+      ]),
+      { width: 120, height: 20 },
+    );
+
+    await flushFrames();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Mixed currencies detected; showing percent change.");
+    expect(frame).toContain("1:1W");
+    expect(frame).toContain("arrows legend");
+    expect(frame).not.toContain("side by side");
+  });
+
+  test("moves legend selection with the keyboard and opens the selected ticker on Enter", async () => {
+    const spy = { selected: [] as string[], focused: [] as string[] };
+    setSharedDataProviderForTests(createProvider({
+      AAPL: [100, 102, 104],
+      MSFT: [200, 202, 204],
+      NVDA: [300, 305, 310],
+    }, {
+      AAPL: "USD",
+      MSFT: "USD",
+      NVDA: "USD",
+    }));
+    setSharedRegistryForTests(createRegistrySpy(spy));
+
+    testSetup = await testRender(
+      createComparisonHarness({
+        axisMode: "percent",
+        symbols: ["AAPL", "MSFT", "NVDA"],
+        symbolsText: "AAPL, MSFT, NVDA",
+      }, [
+        makeTicker("AAPL", "USD"),
+        makeTicker("MSFT", "USD"),
+        makeTicker("NVDA", "USD"),
+      ], [
+        ["AAPL", makeFinancials("AAPL", "USD", [100, 102, 104])],
+        ["MSFT", makeFinancials("MSFT", "USD", [200, 202, 204])],
+        ["NVDA", makeFinancials("NVDA", "USD", [300, 305, 310])],
+      ]),
+      { width: 120, height: 20 },
+    );
+
+    await flushFrames();
+    testSetup.mockInput.pressArrow("right");
+    await flushFrames();
+    testSetup.mockInput.pressEnter();
+    await flushFrames();
+
+    expect(spy.selected).toEqual(["MSFT"]);
+    expect(spy.focused).toEqual(["ticker-detail"]);
+  });
+});
+
+describe("buildComparisonChartPaneTitle", () => {
+  test("summarizes longer symbol lists", () => {
+    expect(buildComparisonChartPaneTitle(["AAPL", "MSFT", "NVDA", "META"])).toBe("AAPL · MSFT +2");
+  });
+});

package/src/plugins/builtin/comparison-chart.tsx

@@ -0,0 +1,169 @@
+import { useCallback, useMemo } from "react";
+import { EmptyState } from "../../components";
+import { ComparisonStockChart } from "../../components/chart/comparison-stock-chart";
+import type { ChartAxisMode } from "../../components/chart/chart-types";
+import { getSharedRegistry } from "../../plugins/registry";
+import { useAppState } from "../../state/app-context";
+import { colors } from "../../theme/colors";
+import type { GloomPlugin, PaneProps, PaneSettingsDef } from "../../types/plugin";
+import { formatTickerListInput, MAX_TICKER_LIST_SIZE, parseTickerListInput } from "../../utils/ticker-list";
+
+export const COMPARISON_CHART_PANE_ID = "comparison-chart";
+export const COMPARISON_CHART_TEMPLATE_ID = "comparison-chart-pane";
+
+interface ComparisonChartPaneSettings {
+  axisMode: ChartAxisMode;
+  symbols: string[];
+  symbolsText: string;
+}
+
+function isChartAxisMode(value: unknown): value is ChartAxisMode {
+  return value === "price" || value === "percent";
+}
+
+function coerceSymbolList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  const parsed = value.filter((entry): entry is string => typeof entry === "string");
+  try {
+    return parseTickerListInput(parsed.join(", "), MAX_TICKER_LIST_SIZE);
+  } catch {
+    return parsed.slice(0, MAX_TICKER_LIST_SIZE);
+  }
+}
+
+export function getComparisonChartPaneSettings(settings: Record<string, unknown> | undefined): ComparisonChartPaneSettings {
+  const storedSymbols = coerceSymbolList(settings?.symbols);
+  const storedText = typeof settings?.symbolsText === "string" ? settings.symbolsText : "";
+  let symbols = storedSymbols;
+
+  if (symbols.length === 0 && storedText.trim().length > 0) {
+    try {
+      symbols = parseTickerListInput(storedText, MAX_TICKER_LIST_SIZE);
+    } catch {
+      symbols = [];
+    }
+  }
+
+  return {
+    axisMode: isChartAxisMode(settings?.axisMode) ? settings.axisMode : "price",
+    symbols,
+    symbolsText: storedText.trim().length > 0 ? storedText : formatTickerListInput(symbols),
+  };
+}
+
+function buildComparisonChartSettingsDef(): PaneSettingsDef {
+  return {
+    title: "Comparison Chart Settings",
+    fields: [
+      {
+        key: "symbolsText",
+        label: "Tickers",
+        description: `Enter 1-${MAX_TICKER_LIST_SIZE} tickers separated by commas.`,
+        type: "text",
+        placeholder: "AAPL, MSFT, NVDA",
+      },
+      {
+        key: "axisMode",
+        label: "Chart Y-Axis",
+        description: "Show prices or percent change from the first visible point on the shared chart.",
+        type: "select",
+        options: [
+          { value: "price", label: "Price" },
+          { value: "percent", label: "Percent" },
+        ],
+      },
+    ],
+  };
+}
+
+export function buildComparisonChartPaneTitle(symbols: string[]): string {
+  if (symbols.length === 0) return "Compare";
+  if (symbols.length <= 3) return symbols.join(" · ");
+  return `${symbols.slice(0, 2).join(" · ")} +${symbols.length - 2}`;
+}
+function ComparisonChartPane({ paneId, focused, width, height }: PaneProps) {
+  const registry = getSharedRegistry();
+  const { state } = useAppState();
+  const pane = state.config.layout.instances.find((instance) => instance.instanceId === paneId);
+  const settings = useMemo(() => getComparisonChartPaneSettings(pane?.settings), [pane?.settings]);
+
+  const openTicker = useCallback((symbol: string) => {
+    registry?.selectTickerFn(symbol);
+    registry?.focusPaneFn("ticker-detail");
+  }, [registry]);
+
+  if (settings.symbols.length === 0) {
+    return (
+      <box flexDirection="column" flexGrow={1} padding={1}>
+        <EmptyState title="No comparison tickers configured." message="Open pane settings to add up to 10 tickers." />
+      </box>
+    );
+  }
+
+  return (
+    <box flexDirection="column" flexGrow={1} paddingX={1} backgroundColor={colors.panel}>
+      <ComparisonStockChart
+        paneId={paneId}
+        width={Math.max(width - 2, 20)}
+        height={Math.max(height, 8)}
+        focused={focused}
+        symbols={settings.symbols}
+        axisMode={settings.axisMode}
+        onOpenSymbol={openTicker}
+      />
+    </box>
+  );
+}
+
+export const comparisonChartPlugin: GloomPlugin = {
+  id: "comparison-chart",
+  name: "Comparison Chart",
+  version: "1.0.0",
+  panes: [
+    {
+      id: COMPARISON_CHART_PANE_ID,
+      name: "Compare",
+      icon: "C",
+      component: ComparisonChartPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultWidth: "50%",
+      settings: buildComparisonChartSettingsDef(),
+    },
+  ],
+  paneTemplates: [
+    {
+      id: COMPARISON_CHART_TEMPLATE_ID,
+      paneId: COMPARISON_CHART_PANE_ID,
+      label: "Comparison Chart",
+      description: "Compare up to 10 ticker charts overlaid on one chart.",
+      keywords: ["compare", "comparison", "chart", "multi", "ticker"],
+      shortcut: { prefix: "CMP", argPlaceholder: "tickers", argKind: "ticker-list" },
+      wizard: [
+        {
+          key: "tickers",
+          label: "Comparison Tickers",
+          placeholder: "AAPL, MSFT, NVDA",
+          body: [
+            `Enter 1-${MAX_TICKER_LIST_SIZE} ticker symbols separated by commas.`,
+          ],
+          type: "text",
+        },
+      ],
+      canCreate: (_context, options) => !options?.symbols || options.symbols.length > 0,
+      createInstance: (_context, options) => {
+        const symbols = options?.symbols ?? [];
+        if (symbols.length === 0) return null;
+        return {
+          title: buildComparisonChartPaneTitle(symbols),
+          placement: "floating",
+          settings: {
+            axisMode: "percent",
+            symbols,
+            symbolsText: formatTickerListInput(symbols),
+          },
+        };
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,16 @@
+import type { AppConfig } from "../../types/config";
+import type { DataProvider } from "../../types/data-provider";
+import { createGloomberbCloudProvider } from "../../sources/gloomberb-cloud";
+import { createYahooProvider } from "./yahoo";
+
+export function createBuiltinDataProviders(config?: Pick<AppConfig, "disabledPlugins">): DataProvider[] {
+  const disabledPlugins = new Set(config?.disabledPlugins ?? []);
+  const providers: DataProvider[] = [];
+
+  if (!disabledPlugins.has("gloomberb-cloud")) {
+    providers.push(createGloomberbCloudProvider());
+  }
+
+  providers.push(createYahooProvider());
+  return providers;
+}