gloomberb 0.9.3 → 0.9.4

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph/content.tsx

@@ -1,23 +1,25 @@
-import { useCallback, useMemo } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import { Box, TextAttributes } from "../../../../../ui";
 import {
   DataTableView,
+  Tabs,
   usePaneFooter,
   type DataTableCell,
   type DataTableKeyEvent,
 } from "../../../../../components";
+import { useShortcut } from "../../../../../react/input";
+import type { BarChartHover } from "../../../../../components/chart/bar-chart-renderer";
 import { StaticBarChartSurface } from "../../../../../components/chart/static/bar-chart-surface";
 import { colors, priceColor } from "../../../../../theme/colors";
 import { usePluginPaneState } from "../../../../runtime";
 import { loadingErrorFooterInfo, refreshFooterHint, useClampSelectedIndex } from "../../../shared/table-pane";
 import {
+  allMetricDefs,
   buildFundamentalColumns,
   buildGraphBarSeries,
-  defaultMetric,
   formatMaybePercent,
-  isMetricForKind,
   metricDef,
-  nextMetric,
+  metricKind,
 } from "./model";
 import type {
   FundamentalColumn,
@@ -41,6 +43,7 @@ export function FundamentalGraphContent({
   setMetric,
   chartKind,
   setChartKind,
+  onCapture,
 }: {
   focused: boolean;
   width: number;
@@ -55,39 +58,106 @@ export function FundamentalGraphContent({
   setMetric: (updater: (current: GraphMetricKey) => GraphMetricKey) => void;
   chartKind: GraphKind;
   setChartKind: (updater: (current: GraphKind) => GraphKind) => void;
+  onCapture?: (capturing: boolean) => void;
 }) {
   const [selectedIdx, setSelectedIdx] = usePluginPaneState<number>("selectedIdx", 0);
+  const [hoveredBar, setHoveredBar] = useState<BarChartHover | null>(null);
+  const [metricTabsFocused, setMetricTabsFocused] = useState(false);
   const definition = metricDef(chartKind, metric);
+  const metricOptions = useMemo(() => allMetricDefs(), []);
+  const metricTabs = useMemo(() => metricOptions.map(({ definition }) => ({
+    label: definition.label,
+    value: definition.key,
+  })), [metricOptions]);
   const multiSymbol = new Set(rows.map((row) => row.symbol)).size > 1;
   const columns = useMemo(() => buildFundamentalColumns(width, multiSymbol), [multiSymbol, width]);
-  const boundedSelectedIdx = rows.length > 0 ? Math.min(selectedIdx, rows.length - 1) : -1;
-  const chartHeight = height >= 14 ? Math.min(12, Math.max(7, Math.floor(height * 0.52))) : Math.max(4, Math.floor(height / 2));
-  const tableHeight = Math.max(4, height - chartHeight);
+  const tableRows = useMemo(() => [...rows].sort((left, right) => (
+    right.date.localeCompare(left.date) || left.symbol.localeCompare(right.symbol)
+  )), [rows]);
+  const boundedSelectedIdx = tableRows.length > 0 ? Math.min(selectedIdx, tableRows.length - 1) : -1;
+  const minTableHeight = tableRows.length > 0 ? 4 : 3;
+  const desiredChartHeight = height >= 14 ? Math.min(16, Math.max(9, Math.floor(height * 0.58))) : Math.max(4, Math.floor(height / 2));
+  const chartHeight = Math.max(1, Math.min(desiredChartHeight, Math.max(1, height - minTableHeight)));
+  const tableHeight = Math.max(0, height - chartHeight);
   const chartSeries = useMemo(() => buildGraphBarSeries(rows), [rows]);
-  const cycleMetric = useCallback(() => setMetric((current) => nextMetric(chartKind, current)), [chartKind, setMetric]);
-  const togglePeriod = useCallback(() => setPeriod((current) => current === "annual" ? "quarterly" : "annual"), [setPeriod]);
-  const toggleGraphKind = useCallback(() => {
-    const nextKind = chartKind === "fundamental" ? "valuation" : "fundamental";
+  const selectMetric = useCallback((value: string) => {
+    const nextMetric = value as GraphMetricKey;
+    const nextKind = metricKind(nextMetric);
+    if (!nextKind) return;
+    setHoveredBar(null);
     setChartKind(() => nextKind);
-    setMetric((current) => isMetricForKind(nextKind, current) ? current : defaultMetric(nextKind));
-  }, [chartKind, setChartKind, setMetric]);
+    setMetric(() => nextMetric);
+  }, [setChartKind, setMetric]);
+  const focusMetricTabs = useCallback(() => {
+    if (metricTabsFocused) return;
+    setMetricTabsFocused(true);
+    onCapture?.(true);
+  }, [metricTabsFocused, onCapture]);
+  const releaseMetricTabs = useCallback(() => {
+    if (!metricTabsFocused) return;
+    setMetricTabsFocused(false);
+    onCapture?.(false);
+  }, [metricTabsFocused, onCapture]);
+  const selectMetricFromTabs = useCallback((value: string) => {
+    focusMetricTabs();
+    selectMetric(value);
+  }, [focusMetricTabs, selectMetric]);
+  const togglePeriod = useCallback(() => setPeriod((current) => current === "annual" ? "quarterly" : "annual"), [setPeriod]);
+  const hoveredValue = useMemo(() => {
+    if (!hoveredBar) return null;
+    const label = chartSeries.length > 1 ? `${hoveredBar.category} ${hoveredBar.seriesLabel}` : hoveredBar.category;
+    return `${label} ${definition.format(hoveredBar.value)}`;
+  }, [chartSeries.length, definition, hoveredBar]);
+
+  useClampSelectedIndex(tableRows.length, selectedIdx, setSelectedIdx);
+
+  useEffect(() => {
+    if (!focused && metricTabsFocused) {
+      setMetricTabsFocused(false);
+      onCapture?.(false);
+    }
+  }, [focused, metricTabsFocused, onCapture]);
+
+  useEffect(() => () => {
+    onCapture?.(false);
+  }, [onCapture]);
 
-  useClampSelectedIndex(rows.length, selectedIdx, setSelectedIdx);
+  useShortcut((event) => {
+    if (event.defaultPrevented || event.propagationStopped || event.targetEditable) return;
+    if (event.ctrl || event.meta || event.alt || event.shift) return;
+
+    const isEnter = event.name === "enter" || event.name === "return";
+    const isEscape = event.name === "escape" || event.name === "esc";
+    if (isEnter) {
+      event.preventDefault();
+      event.stopPropagation();
+      focusMetricTabs();
+      return;
+    }
+    if (isEscape && metricTabsFocused) {
+      event.preventDefault();
+      event.stopPropagation();
+      releaseMetricTabs();
+    }
+  }, { enabled: focused, phase: "before" });
 
   const handleKeyDown = useCallback((event: DataTableKeyEvent) => {
-    if (event.name === "r") {
+    const isEnter = event.name === "enter" || event.name === "return";
+    if (isEnter) {
       event.preventDefault?.();
-      reload();
+      event.stopPropagation?.();
+      focusMetricTabs();
       return true;
     }
-    if (event.name === "m") {
+    if ((event.name === "escape" || event.name === "esc") && metricTabsFocused) {
       event.preventDefault?.();
-      cycleMetric();
+      event.stopPropagation?.();
+      releaseMetricTabs();
       return true;
     }
-    if (event.name === "g") {
+    if (event.name === "r") {
       event.preventDefault?.();
-      toggleGraphKind();
+      reload();
       return true;
     }
     if (event.name === "p") {
@@ -96,7 +166,7 @@ export function FundamentalGraphContent({
       return true;
     }
     return false;
-  }, [cycleMetric, reload, toggleGraphKind, togglePeriod]);
+  }, [focusMetricTabs, metricTabsFocused, releaseMetricTabs, reload, togglePeriod]);
 
   const renderCell = useCallback((
     row: FundamentalGraphRow,
@@ -111,7 +181,11 @@ export function FundamentalGraphContent({
       case "date":
         return { text: row.date, color: selectedColor ?? colors.textDim };
       case "value":
-        return { text: definition.format(row.value), color: selectedColor ?? colors.textBright, attributes: TextAttributes.BOLD };
+        return {
+          text: definition.format(row.value),
+          color: row.value < 0 ? colors.negative : selectedColor ?? colors.textBright,
+          attributes: TextAttributes.BOLD,
+        };
       case "growth":
         return { text: formatMaybePercent(row.growth), color: selectedColor ?? priceColor(row.growth ?? 0) };
     }
@@ -119,41 +193,68 @@ export function FundamentalGraphContent({
 
   usePaneFooter("fundamental-graph", () => ({
     info: [
-      { id: "metric", parts: [{ text: definition.label, tone: "muted" as const }] },
-      { id: "kind", parts: [{ text: chartKind === "valuation" ? "valuation" : "fundamental", tone: "muted" as const }] },
-      { id: "period", parts: [{ text: period, tone: "muted" as const }] },
+      { id: "period", parts: [{ text: "period", tone: "label" as const }, { text: period, tone: "value" as const }] },
+      ...(hoveredValue ? [{ id: "hover", parts: [{ text: hoveredValue, tone: "value" as const }] }] : []),
       ...loadingErrorFooterInfo(loading, error),
     ],
     hints: [
-      { id: "metric", key: "m", label: "etric", onPress: cycleMetric },
-      { id: "kind", key: "g", label: "raph", onPress: toggleGraphKind },
       { id: "period", key: "p", label: "eriod", onPress: togglePeriod },
       refreshFooterHint(reload),
     ],
-  }), [chartKind, cycleMetric, definition.label, error, loading, period, reload, toggleGraphKind, togglePeriod]);
+  }), [error, hoveredValue, loading, period, reload, togglePeriod]);
+
+  const metricHeader = (
+    <Tabs
+      tabs={metricTabs}
+      activeValue={metric}
+      onSelect={selectMetricFromTabs}
+      compact
+      focused={focused && metricTabsFocused}
+      keyboardNavigation={metricTabsFocused}
+      scrollable
+      variant="underline"
+    />
+  );
 
   return (
-    <Box flexDirection="column" width={width} height={height} overflow="hidden">
-      <StaticBarChartSurface width={width} height={chartHeight} series={chartSeries} />
-      <DataTableView<FundamentalGraphRow, FundamentalColumn>
-        focused={focused}
-        selection={{
-          kind: "index",
-          selectedIndex: boundedSelectedIdx,
-          onChange: (index) => setSelectedIdx(index),
-        }}
-        onRootKeyDown={handleKeyDown}
-        rootWidth={width}
-        rootHeight={tableHeight}
-        columns={columns}
-        items={rows}
-        sortColumnId={null}
-        sortDirection="asc"
-        onHeaderClick={() => {}}
-        getItemKey={(row) => row.key}
-        renderCell={renderCell}
-        emptyStateTitle={loading ? "Loading fundamentals..." : "No graph data"}
+    <Box
+      flexDirection="column"
+      width={width}
+      height={height}
+      overflow="hidden"
+      onMouseDown={focusMetricTabs}
+    >
+      <StaticBarChartSurface
+        width={width}
+        height={chartHeight}
+        series={chartSeries}
+        header={metricHeader}
+        formatValue={definition.format}
+        onHoverChange={setHoveredBar}
+        onMouseDown={focusMetricTabs}
       />
+      {tableHeight > 0 ? (
+        <DataTableView<FundamentalGraphRow, FundamentalColumn>
+          focused={focused}
+          selection={{
+            kind: "index",
+            selectedIndex: boundedSelectedIdx,
+            onChange: (index) => setSelectedIdx(index),
+          }}
+          onRootKeyDown={handleKeyDown}
+          rootWidth={width}
+          rootHeight={tableHeight}
+          columns={columns}
+          items={tableRows}
+          sortColumnId="date"
+          sortDirection="desc"
+          onHeaderClick={() => {}}
+          onTableMouseDown={focusMetricTabs}
+          getItemKey={(row) => row.key}
+          renderCell={renderCell}
+          emptyStateTitle={loading ? "Loading fundamentals..." : "No graph data"}
+        />
+      ) : null}
     </Box>
   );
 }

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph/model.ts

@@ -71,9 +71,19 @@ export function buildFundamentalGraphRows(
   symbol = "",
   period: FundamentalPeriod = "annual",
 ): FundamentalGraphRow[] {
-  const sorted = [...statements]
+  const sortedStatements = [...statements]
     .filter((statement) => typeof statement[metric] === "number")
     .sort((left, right) => left.date.localeCompare(right.date));
+  const byCategory = new Map<string, FinancialStatement>();
+  for (const statement of sortedStatements) {
+    const category = periodCategory(statement.date, period);
+    const key = `${symbol}\u0000${category}`;
+    const previous = byCategory.get(key);
+    if (!previous || statement.date.localeCompare(previous.date) >= 0) {
+      byCategory.set(key, statement);
+    }
+  }
+  const sorted = [...byCategory.values()].sort((left, right) => left.date.localeCompare(right.date));
   const maxAbs = Math.max(1, ...sorted.map((statement) => Math.abs(statement[metric] as number)));
   return sorted.map((statement, index) => {
     const value = statement[metric] as number;
@@ -159,10 +169,23 @@ export function buildValuationGraphRows(
   });
 }
 
-function metricDefs(kind: GraphKind): ReadonlyArray<MetricDefinition> {
+export function metricDefs(kind: GraphKind): ReadonlyArray<MetricDefinition> {
   return kind === "valuation" ? VALUATION_METRICS : FUNDAMENTAL_METRICS;
 }
 
+export function allMetricDefs(): ReadonlyArray<{ kind: GraphKind; definition: MetricDefinition }> {
+  return [
+    ...FUNDAMENTAL_METRICS.map((definition) => ({ kind: "fundamental" as const, definition })),
+    ...VALUATION_METRICS.map((definition) => ({ kind: "valuation" as const, definition })),
+  ];
+}
+
+export function metricKind(metric: GraphMetricKey): GraphKind | null {
+  if (FUNDAMENTAL_METRICS.some((definition) => definition.key === metric)) return "fundamental";
+  if (VALUATION_METRICS.some((definition) => definition.key === metric)) return "valuation";
+  return null;
+}
+
 export function defaultMetric(kind: GraphKind): GraphMetricKey {
   return kind === "valuation" ? "priceSales" : "totalRevenue";
 }

package/src/plugins/builtin/ticker-detail/data-panes/fundamental-graph.tsx

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import type { PaneProps, PaneTemplateDef } from "../../../../types/plugin";
+import type { PaneProps, PaneTemplateDef, TickerResearchTabProps } from "../../../../types/plugin";
 import { formatTickerListInput } from "../../../../tickers/list";
 import { usePaneInstance, usePaneTicker } from "../../../../state/app/context";
 import { usePluginPaneState } from "../../../runtime";
@@ -26,7 +26,7 @@ export function FundamentalGraphPane({ focused, width, height }: PaneProps) {
   const { symbol, exchange } = useBoundTicker();
   const symbols = useMemo(() => symbolsFromPaneSettings(pane?.settings, symbol), [pane?.settings, symbol]);
   const configuredKind = graphKindFromSettings(pane?.settings, "fundamental");
-  const [period, setPeriod] = usePluginPaneState<FundamentalPeriod>("period", "annual");
+  const [period, setPeriod] = usePluginPaneState<FundamentalPeriod>("period", "quarterly");
   const [chartKind, setChartKind] = usePluginPaneState<GraphKind>("chartKind", configuredKind);
   const [metric, setMetric] = usePluginPaneState<GraphMetricKey>("metric", defaultMetric(configuredKind));
   const resolvedMetric = isMetricForKind(chartKind, metric) ? metric : defaultMetric(chartKind);
@@ -54,9 +54,9 @@ export function FundamentalGraphPane({ focused, width, height }: PaneProps) {
   );
 }
 
-export function FundamentalGraphsResearchTab({ focused, width, height }: { focused: boolean; width: number; height: number }) {
+export function FundamentalGraphsResearchTab({ focused, width, height, onCapture }: TickerResearchTabProps) {
   const { symbol, financials } = usePaneTicker();
-  const [period, setPeriod] = usePluginPaneState<FundamentalPeriod>("detailPeriod", "annual");
+  const [period, setPeriod] = usePluginPaneState<FundamentalPeriod>("detailPeriod", "quarterly");
   const [chartKind, setChartKind] = usePluginPaneState<GraphKind>("detailChartKind", "fundamental");
   const [metric, setMetric] = usePluginPaneState<GraphMetricKey>("detailMetric", "totalRevenue");
   const resolvedMetric = isMetricForKind(chartKind, metric) ? metric : defaultMetric(chartKind);
@@ -79,6 +79,7 @@ export function FundamentalGraphsResearchTab({ focused, width, height }: { focus
       setMetric={setMetric}
       chartKind={chartKind}
       setChartKind={setChartKind}
+      onCapture={onCapture}
     />
   );
 }

package/src/plugins/builtin/ticker-detail/data-panes.test.ts

@@ -49,6 +49,22 @@ describe("ticker data panes", () => {
     ]);
   });
 
+  test("collapses duplicate quarterly statement dates into one displayed period", () => {
+    const rows = buildFundamentalGraphRows([
+      { date: "2025-03-29", eps: 0.44 },
+      { date: "2025-03-31", eps: 0.44 },
+      { date: "2025-06-28", eps: 0.54 },
+      { date: "2025-06-30", eps: 0.54 },
+      { date: "2025-09-27", eps: 0.75 },
+    ] satisfies FinancialStatement[], "eps", "AMD", "quarterly");
+
+    expect(rows.map((row) => [row.date, row.category, row.value])).toEqual([
+      ["2025-03-31", "2025 Q1", 0.44],
+      ["2025-06-30", "2025 Q2", 0.54],
+      ["2025-09-27", "2025 Q3", 0.75],
+    ]);
+  });
+
   test("builds valuation graph rows from available multiples", () => {
     const rows = buildValuationGraphRows({
       quote: { symbol: "AMD", price: 100, currency: "USD", change: 0, changePercent: 0, lastUpdated: 1, marketCap: 1_000 },

package/src/plugins/builtin/ticker-detail/index.test.tsx

@@ -305,6 +305,25 @@ async function clickFrameText(text: string) {
   await flushFrame();
 }
 
+async function emitKeypress(event: { name?: string; sequence?: string }) {
+  await act(async () => {
+    (testSetup!.renderer as any).keyInput.emit("keypress", {
+      ctrl: false,
+      meta: false,
+      option: false,
+      shift: false,
+      eventType: "press",
+      repeated: false,
+      preventDefault: () => {},
+      stopPropagation: () => {},
+      ...event,
+    });
+    await Promise.resolve();
+    await testSetup!.renderOnce();
+  });
+  await flushFrame();
+}
+
 function spanLineText(line: { spans: Array<{ text: string }> }): string {
   return line.spans.map((span) => span.text).join("");
 }
@@ -531,6 +550,130 @@ describe("TickerResearchPane", () => {
     expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("financials");
   });
 
+  test("shows metric tabs for fundamental graph charts and defaults them to quarterly data", async () => {
+    setSharedRegistryForTests(makeRegistry());
+    setOptionsProvider(createProvider(false));
+
+    testSetup = await testRender(
+      <DetailHarness
+        config={createDetailConfig("AAPL")}
+        ticker={makeTicker("AAPL")}
+        financials={makeFinancials({
+          annualStatements: [{ date: "2024-12-31", totalRevenue: 1_000 }],
+          quarterlyStatements: [
+            { date: "2025-03-31", totalRevenue: 200 },
+            { date: "2025-06-30", totalRevenue: 250 },
+          ],
+        })}
+        activeTabId="fundamental-graphs"
+        height={28}
+      />,
+      { width: 90, height: 28 },
+    );
+
+    await flushFrame();
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("Revenue");
+    expect(frame).toContain("Gross Profit");
+    expect(frame).not.toContain("Revenue (quarterly)");
+    expect(frame).not.toContain("[g]roup");
+    expect(frame).toContain("2025-03-31");
+    expect(frame).toContain("2025-06-30");
+    expect(frame.indexOf("2025-06-30")).toBeLessThan(frame.indexOf("2025-03-31"));
+  });
+
+  test("captures arrows for graph metric tabs between enter and escape", async () => {
+    setSharedRegistryForTests(makeRegistry());
+    setOptionsProvider(createProvider(false));
+
+    testSetup = await testRender(
+      <DetailHarness
+        config={createDetailConfig("AAPL")}
+        ticker={makeTicker("AAPL")}
+        financials={makeFinancials({
+          annualStatements: [{ date: "2024-12-31", totalRevenue: 1_000, grossProfit: 400 }],
+          quarterlyStatements: [
+            { date: "2025-03-31", totalRevenue: 200, grossProfit: 80 },
+            { date: "2025-06-30", totalRevenue: 250, grossProfit: 120 },
+          ],
+        })}
+        activeTabId="fundamental-graphs"
+        height={28}
+      />,
+      { width: 90, height: 28 },
+    );
+
+    await flushFrame();
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("fundamental-graphs");
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    await act(async () => {
+      testSetup!.mockInput.pressArrow("right");
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.pluginState?.["ticker-detail"]?.detailMetric).toBe("grossProfit");
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("fundamental-graphs");
+
+    await emitKeypress({ name: "escape", sequence: "\u001b" });
+    expect(detailHarnessState?.inputCaptured).toBe(false);
+
+    await act(async () => {
+      testSetup!.mockInput.pressArrow("right");
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    await settleTickerTabCommit();
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("chart");
+  });
+
+  test("clicking graph content focuses metric tabs for arrow navigation", async () => {
+    setSharedRegistryForTests(makeRegistry());
+    setOptionsProvider(createProvider(false));
+
+    testSetup = await testRender(
+      <DetailHarness
+        config={createDetailConfig("AAPL")}
+        ticker={makeTicker("AAPL")}
+        financials={makeFinancials({
+          annualStatements: [{ date: "2024-12-31", totalRevenue: 1_000, grossProfit: 400 }],
+          quarterlyStatements: [
+            { date: "2025-03-31", totalRevenue: 200, grossProfit: 80 },
+            { date: "2025-06-30", totalRevenue: 250, grossProfit: 120 },
+          ],
+        })}
+        activeTabId="fundamental-graphs"
+        height={28}
+      />,
+      { width: 90, height: 28 },
+    );
+
+    await flushFrame();
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(24, 6);
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+    expect(detailHarnessState?.inputCaptured).toBe(true);
+
+    await act(async () => {
+      testSetup!.mockInput.pressArrow("right");
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.pluginState?.["ticker-detail"]?.detailMetric).toBe("grossProfit");
+    expect(detailHarnessState?.paneState[TEST_PANE_ID]?.activeTabId).toBe("fundamental-graphs");
+  });
+
   test("shows Trade when an IBKR gateway profile exists", async () => {
     setSharedRegistryForTests(makeRegistry());
     setOptionsProvider(createProvider(false));

package/src/plugins/catalog-ui.ts

@@ -12,6 +12,7 @@ import { layoutManagerPlugin } from "./builtin/layout-manager";
 import { predictionMarketsPlugin } from "./prediction-markets";
 import { analyticsPlugin } from "./builtin/analytics";
 import { alertsPlugin } from "./builtin/alerts";
+import { kellySizerPlugin } from "./builtin/kelly-sizer";
 import {
   brokerPlugin,
   macroPlugin,
@@ -36,6 +37,7 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   marketOverviewPlugin,
   macroPlugin,
   analyticsPlugin,
+  kellySizerPlugin,
   alertsPlugin,
 ];
 

package/src/plugins/ibkr/broker-adapter.ts

@@ -40,6 +40,25 @@ export const ibkrBroker: BrokerAdapter = {
     return importFlexPositions(normalized.flex);
   },
 
+  async importPortfolioSnapshot(instance) {
+    const normalized = normalizeIbkrConfig(instance.config);
+    if (normalized.connectionMode === "gateway") {
+      const service = ibkrGatewayManager.getService(instance.id);
+      await refreshGatewayData(instance);
+      const [accounts, positions] = await Promise.all([
+        service.getAccounts(normalized.gateway),
+        service.getPositions(normalized.gateway),
+      ]);
+      return { accounts, positions };
+    }
+
+    const xml = await loadFlexStatement(normalized.flex);
+    return {
+      accounts: parseFlexAccounts(xml),
+      positions: parseFlexPositions(xml),
+    };
+  },
+
   async connect(instance) {
     const normalized = normalizeIbkrConfig(instance.config);
     if (normalized.connectionMode !== "gateway") return;

package/src/plugins/ibkr/config.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, test } from "bun:test";
-import { buildIbkrConfigFromValues, normalizeIbkrConfig } from "./config";
+import {
+  buildIbkrConfigFromValues,
+  IBKR_STATEMENT_URL,
+  LEGACY_IBKR_STATEMENT_URL,
+  normalizeIbkrConfig,
+} from "./config";
 
 describe("ibkr config helpers", () => {
   test("builds nested manual gateway config from flat wizard values", () => {
@@ -45,6 +50,30 @@ describe("ibkr config helpers", () => {
     expect(config.gatewaySetupMode).toBe("auto");
     expect(config.flex.token).toBe("abc");
     expect(config.flex.queryId).toBe("123");
-    expect(config.flex.endpoint).toContain("FlexStatementService.SendRequest");
+    expect(config.flex.endpoint).toBe(IBKR_STATEMENT_URL);
+  });
+
+  test("migrates the legacy default Flex endpoint to the current IBKR endpoint", () => {
+    const config = normalizeIbkrConfig({
+      flex: {
+        token: "abc",
+        queryId: "123",
+        endpoint: LEGACY_IBKR_STATEMENT_URL,
+      },
+    });
+
+    expect(config.flex.endpoint).toBe(IBKR_STATEMENT_URL);
+  });
+
+  test("preserves custom non-default Flex endpoints", () => {
+    const config = normalizeIbkrConfig({
+      flex: {
+        token: "abc",
+        queryId: "123",
+        endpoint: "https://example.com/custom/SendRequest",
+      },
+    });
+
+    expect(config.flex.endpoint).toBe("https://example.com/custom/SendRequest");
   });
 });

package/src/plugins/ibkr/config.ts

@@ -1,7 +1,8 @@
 import type { BrokerConfigField } from "../../types/broker";
 import type { IbkrGatewayConfig, ResolvedIbkrGatewayConnection } from "./gateway/service";
 
-export const IBKR_STATEMENT_URL = "https://gdcdyn.interactivebrokers.com/Universal/servlet/FlexStatementService.SendRequest";
+export const LEGACY_IBKR_STATEMENT_URL = "https://gdcdyn.interactivebrokers.com/Universal/servlet/FlexStatementService.SendRequest";
+export const IBKR_STATEMENT_URL = "https://ndcdyn.interactivebrokers.com/AccountManagement/FlexWebService/SendRequest";
 
 type IbkrConnectionMode = "flex" | "gateway";
 type IbkrGatewaySetupMode = "auto" | "manual";
@@ -119,6 +120,12 @@ function coerceString(value: unknown, fallback = ""): string {
   return typeof value === "string" ? value : fallback;
 }
 
+function normalizeFlexEndpoint(value: unknown): string {
+  const endpoint = coerceString(value, DEFAULT_FLEX_CONFIG.endpoint).trim();
+  if (!endpoint || endpoint === LEGACY_IBKR_STATEMENT_URL) return IBKR_STATEMENT_URL;
+  return endpoint;
+}
+
 function getMode(value: unknown): IbkrConnectionMode {
   return value === "gateway" ? "gateway" : "flex";
 }
@@ -166,7 +173,7 @@ export function normalizeIbkrConfig(raw?: Record<string, unknown>): IbkrConfig {
     flex: {
       token: coerceString(nestedFlex.token ?? input.token),
       queryId: coerceString(nestedFlex.queryId ?? input.queryId),
-      endpoint: coerceString(nestedFlex.endpoint ?? input.endpoint, DEFAULT_FLEX_CONFIG.endpoint),
+      endpoint: normalizeFlexEndpoint(nestedFlex.endpoint ?? input.endpoint),
     },
     gateway: {
       host,