gloomberb 0.2.0 → 0.3.2

package/src/plugins/ibkr/trade-utils.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, test } from "bun:test";
+import { createDefaultConfig, type AppConfig, type BrokerInstanceConfig } from "../../types/config";
+import type { TickerRecord } from "../../types/ticker";
+import {
+  findTickerForOrder,
+  formatContractLabel,
+  formatPreviewMetric,
+  formatPreviewSummary,
+  formatQuoteSummary,
+  getKnownIbkrAccounts,
+  getTradeTonePalette,
+  hasIbkrTradingProfiles,
+  inferDraftAccountId,
+  isLimitOrder,
+  isMarketDataWarning,
+  isStopOrder,
+  truncateTradeText,
+} from "./trade-utils";
+
+function createGatewayInstance(): BrokerInstanceConfig {
+  return {
+    id: "ibkr-paper",
+    brokerType: "ibkr",
+    label: "Paper",
+    connectionMode: "gateway",
+    config: { connectionMode: "gateway", gateway: { host: "127.0.0.1", port: 4002, clientId: 1 } },
+    enabled: true,
+  };
+}
+
+function createFlexInstance(): BrokerInstanceConfig {
+  return {
+    id: "ibkr-flex",
+    brokerType: "ibkr",
+    label: "Flex",
+    connectionMode: "flex",
+    config: { connectionMode: "flex", flex: { token: "token", queryId: "query" } },
+    enabled: true,
+  };
+}
+
+function createConfig(brokerInstances: BrokerInstanceConfig[] = []): AppConfig {
+  return {
+    ...createDefaultConfig("/tmp/gloomberb-trade-utils"),
+    brokerInstances,
+  };
+}
+
+function createTicker(symbol: string): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: symbol,
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+describe("trade-utils", () => {
+  test("detects configured IBKR gateway profiles", () => {
+    expect(hasIbkrTradingProfiles(createConfig())).toBe(false);
+    expect(hasIbkrTradingProfiles(createConfig([createFlexInstance()]))).toBe(false);
+    expect(hasIbkrTradingProfiles(createConfig([createGatewayInstance()]))).toBe(true);
+  });
+
+  test("infers account ids from portfolio, preferred account, or single account", () => {
+    const config = createConfig([createGatewayInstance()]);
+    config.portfolios = [{
+      id: "portfolio:ibkr",
+      name: "IBKR",
+      currency: "USD",
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-paper",
+      brokerAccountId: "DU111",
+    }];
+
+    expect(inferDraftAccountId(config, "portfolio:ibkr", [{ accountId: "DU999", name: "Other" }], "ibkr-paper")).toBe("DU111");
+    expect(inferDraftAccountId(config, null, [{ accountId: "DU999", name: "Other" }], "ibkr-paper", "DU999")).toBe("DU999");
+    expect(inferDraftAccountId(config, null, [{ accountId: "DU123", name: "Only" }], "ibkr-paper")).toBe("DU123");
+  });
+
+  test("merges cached and live accounts by account id", () => {
+    const accounts = getKnownIbkrAccounts(
+      {
+        "ibkr-paper": [{
+          accountId: "DU123",
+          name: "Cached",
+          currency: "USD",
+          netLiquidation: 1000,
+        }],
+      },
+      "ibkr-paper",
+      [{
+        accountId: "DU123",
+        name: "Live",
+        currency: "USD",
+        availableFunds: 500,
+      }],
+    );
+
+    expect(accounts).toEqual([{
+      accountId: "DU123",
+      name: "Live",
+      currency: "USD",
+      netLiquidation: 1000,
+      availableFunds: 500,
+    }]);
+  });
+
+  test("formats contract, quote, preview, and truncation helpers", () => {
+    expect(formatContractLabel({ symbol: "AAPL", localSymbol: "AAPL  240621C00190000", secType: "OPT" })).toBe("AAPL  240621C00190000 OPT");
+    expect(formatQuoteSummary()).toBe("No broker quote loaded");
+    expect(formatQuoteSummary({
+      symbol: "AAPL",
+      price: 190.25,
+      currency: "USD",
+      change: 1.5,
+      changePercent: 0.79,
+      bid: 190.2,
+      ask: 190.3,
+      lastUpdated: Date.now(),
+    })).toContain("Spd 0.10");
+    expect(formatPreviewSummary(null)).toContain("Preview required before submit");
+    expect(formatPreviewSummary({
+      initMarginBefore: 12000,
+      initMarginAfter: 13000,
+      commission: 1.25,
+      commissionCurrency: "USD",
+    } as any)).toContain("What-if: init");
+    expect(formatPreviewMetric(10, 15)).toBe("10 → 15");
+    expect(truncateTradeText("ABCDEFGHIJ", 6)).toBe("ABC...");
+  });
+
+  test("detects order type variants and market data warnings", () => {
+    expect(isLimitOrder("LMT")).toBe(true);
+    expect(isLimitOrder("STP")).toBe(false);
+    expect(isStopOrder("STP LMT")).toBe(true);
+    expect(isMarketDataWarning("Delayed market data is not subscribed")).toBe(true);
+    expect(getTradeTonePalette("positive").text).toBeDefined();
+  });
+
+  test("resolves order tickers by direct symbol or broker contract metadata", () => {
+    const amd = createTicker("AMD");
+    const spyOption: TickerRecord = {
+      ...createTicker("SPY250117C00600000"),
+      metadata: {
+        ...createTicker("SPY250117C00600000").metadata,
+        broker_contracts: [{
+          brokerId: "ibkr",
+          brokerInstanceId: "ibkr-paper",
+          symbol: "SPY",
+          localSymbol: "SPY  250117C00600000",
+          conId: 123,
+        }],
+      },
+    };
+    const tickers = new Map([
+      ["AMD", amd],
+      ["SPY250117C00600000", spyOption],
+    ]);
+
+    expect(findTickerForOrder({
+      contract: { symbol: "AMD", brokerInstanceId: "ibkr-paper" },
+    }, tickers)?.metadata.ticker).toBe("AMD");
+    expect(findTickerForOrder({
+      contract: { symbol: "SPY", localSymbol: "SPY  250117C00600000", conId: 123, brokerInstanceId: "ibkr-paper" },
+    }, tickers)?.metadata.ticker).toBe("SPY250117C00600000");
+  });
+});

package/src/plugins/ibkr/trade-utils.ts

@@ -0,0 +1,149 @@
+import type { AppConfig } from "../../types/config";
+import type { Quote } from "../../types/financials";
+import type { BrokerContractRef } from "../../types/instrument";
+import type { TickerRecord } from "../../types/ticker";
+import type { BrokerAccount, BrokerOrderPreview, BrokerOrderType } from "../../types/trading";
+import { colors } from "../../theme/colors";
+import { formatCompact, formatCurrency } from "../../utils/format";
+import { getConfiguredIbkrGatewayInstances } from "./instance-selection";
+
+export type TradeTone = "neutral" | "accent" | "positive" | "negative";
+
+export function isLimitOrder(orderType: BrokerOrderType): boolean {
+  return orderType === "LMT" || orderType === "STP LMT";
+}
+
+export function isStopOrder(orderType: BrokerOrderType): boolean {
+  return orderType === "STP" || orderType === "STP LMT";
+}
+
+export function hasIbkrTradingProfiles(appConfig: AppConfig): boolean {
+  return getConfiguredIbkrGatewayInstances(appConfig).length > 0;
+}
+
+export function inferDraftAccountId(
+  appConfig: AppConfig,
+  collectionId: string | null,
+  accounts: BrokerAccount[],
+  brokerInstanceId?: string,
+  preferredAccountId?: string,
+): string | undefined {
+  const portfolio = appConfig.portfolios.find((entry) => entry.id === collectionId);
+  if (
+    portfolio?.brokerId === "ibkr"
+    && portfolio.brokerAccountId
+    && (!brokerInstanceId || portfolio.brokerInstanceId === brokerInstanceId)
+  ) {
+    return portfolio.brokerAccountId;
+  }
+  if (preferredAccountId && accounts.some((account) => account.accountId === preferredAccountId)) {
+    return preferredAccountId;
+  }
+  if (accounts.length === 1) return accounts[0]!.accountId;
+  return undefined;
+}
+
+export function getKnownIbkrAccounts(
+  brokerAccountsByInstance: Record<string, BrokerAccount[]>,
+  brokerInstanceId: string | undefined,
+  liveAccounts: BrokerAccount[],
+): BrokerAccount[] {
+  if (!brokerInstanceId) return liveAccounts;
+  const cachedAccounts = brokerAccountsByInstance[brokerInstanceId] ?? [];
+  if (liveAccounts.length === 0) return cachedAccounts;
+  if (cachedAccounts.length === 0) return liveAccounts;
+
+  const merged = new Map<string, BrokerAccount>();
+  for (const account of cachedAccounts) {
+    if (!account.accountId) continue;
+    merged.set(account.accountId, account);
+  }
+  for (const account of liveAccounts) {
+    if (!account.accountId) continue;
+    merged.set(account.accountId, { ...(merged.get(account.accountId) ?? {}), ...account });
+  }
+  return [...merged.values()];
+}
+
+export function formatContractLabel(contract: BrokerContractRef): string {
+  const base = contract.localSymbol || contract.symbol;
+  const suffix = contract.secType ? ` ${contract.secType}` : "";
+  return `${base}${suffix}`;
+}
+
+export function formatQuoteSummary(quote?: Quote): string {
+  if (!quote) return "No broker quote loaded";
+  const change = `${quote.change >= 0 ? "+" : ""}${quote.change.toFixed(2)}`;
+  const parts = [`${formatCurrency(quote.price, quote.currency)}  ${change}`];
+  if (quote.bid != null) parts.push(`Bid ${quote.bid.toFixed(2)}`);
+  if (quote.ask != null) parts.push(`Ask ${quote.ask.toFixed(2)}`);
+  if (quote.bid != null && quote.ask != null) parts.push(`Spd ${(quote.ask - quote.bid).toFixed(2)}`);
+  return parts.join(" · ");
+}
+
+export function formatPreviewSummary(preview: BrokerOrderPreview | null): string {
+  if (!preview) {
+    return "Preview required before submit. Press p to review margin and commission.";
+  }
+  return `What-if: init ${formatCompact(preview.initMarginBefore || 0)} → ${formatCompact(preview.initMarginAfter || 0)} · commission ${preview.commission != null ? formatCurrency(preview.commission, preview.commissionCurrency || "USD") : "—"}`;
+}
+
+export function getTradeTonePalette(tone: TradeTone) {
+  switch (tone) {
+    case "accent":
+      return { border: colors.borderFocused, text: colors.textBright, background: colors.selected };
+    case "positive":
+      return { border: colors.positive, text: colors.positive, background: colors.panel };
+    case "negative":
+      return { border: colors.negative, text: colors.negative, background: colors.panel };
+    case "neutral":
+    default:
+      return { border: colors.border, text: colors.text, background: colors.panel };
+  }
+}
+
+export function formatPreviewMetric(before?: number, after?: number): string {
+  if (before == null && after == null) return "—";
+  return `${formatCompact(before || 0)} → ${formatCompact(after || 0)}`;
+}
+
+export function truncateTradeText(value: string, maxWidth: number): string {
+  if (maxWidth <= 0) return "";
+  if (value.length <= maxWidth) return value;
+  if (maxWidth <= 3) return value.slice(0, maxWidth);
+  return `${value.slice(0, maxWidth - 3)}...`;
+}
+
+export function findTickerForOrder(
+  order: { contract: BrokerContractRef },
+  tickers: Map<string, TickerRecord>,
+): TickerRecord | null {
+  const primaryKey = order.contract.localSymbol || order.contract.symbol;
+  const direct = tickers.get(primaryKey);
+  if (direct) return direct;
+
+  const fallback = tickers.get(order.contract.symbol);
+  if (fallback) return fallback;
+
+  for (const ticker of tickers.values()) {
+    const hasContract = (ticker.metadata.broker_contracts ?? []).some((contract) =>
+      contract.brokerId === "ibkr"
+      && contract.brokerInstanceId === order.contract.brokerInstanceId
+      && (
+        (contract.conId != null && contract.conId === order.contract.conId)
+        || (contract.localSymbol && contract.localSymbol === order.contract.localSymbol)
+        || contract.symbol === order.contract.symbol
+      ),
+    );
+    if (hasContract) return ticker;
+  }
+
+  return null;
+}
+
+export function isMarketDataWarning(message?: string): boolean {
+  const text = (message || "").toLowerCase();
+  return text.includes("delayed market data")
+    || text.includes("market data is not subscribed")
+    || text.includes("market data requires additional subscription");
+}