gloomberb 0.7.5 → 0.8.0

package/src/cli/helpers.ts

@@ -4,7 +4,7 @@ import {
   formatNumber,
   formatPercentRaw,
 } from "../utils/format";
-import { formatMarketPriceWithCurrency } from "../utils/market-format";
+import { formatMarketPriceWithCurrency } from "../market-data/market/format";
 
 export { slugifyName } from "../utils/slugify";
 import type { AppConfig } from "../types/config";

package/src/cli/index.ts

@@ -19,6 +19,7 @@ import {
   removePlugin,
   updatePlugins,
 } from "./commands/plugins";
+import { runPaneCatalog, runPaneFunction, runPaneScreenshot } from "./pane-functions";
 
 function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
   return [
@@ -64,6 +65,39 @@ function createCoreCliCommands(renderHelp: () => string): CliCommandDef[] {
         });
       },
     },
+    {
+      name: "fn",
+      aliases: ["function"],
+      description: "Run a pane-backed market function and print a human-readable report",
+      help: {
+        usage: ["fn <function-or-pane> [argument] [--key value]"],
+      },
+      execute: async (args, ctx) => {
+        await runPaneFunction(args, ctx);
+      },
+    },
+    {
+      name: "shot",
+      aliases: ["screenshot"],
+      description: "Render a desktop-style screenshot for a pane-backed market function",
+      help: {
+        usage: ["shot <function-or-pane> [argument] [--output path] [--width px] [--height px] [--key value]"],
+      },
+      execute: async (args, ctx) => {
+        await runPaneScreenshot(args, ctx);
+      },
+    },
+    {
+      name: "catalog",
+      aliases: ["functions", "capabilities"],
+      description: "List searchable pane-backed market functions and screenshots",
+      help: {
+        usage: ["catalog [query] [--limit n] [--all]"],
+      },
+      execute: async (args, ctx) => {
+        await runPaneCatalog(args, ctx);
+      },
+    },
     {
       name: "install",
       description: "Install a plugin from GitHub",

package/src/cli/pane-functions/catalog.ts

@@ -0,0 +1,243 @@
+import type { PaneDef, PaneTemplateCreateOptions, PaneTemplateDef } from "../../types/plugin";
+import type { MarketContext } from "../types";
+import {
+  buildCreateOptions,
+  normalizeLookupToken,
+  type ParsedPaneCatalogArgs,
+} from "./options";
+
+export interface PaneFunctionCatalog {
+  panes: ReadonlyMap<string, PaneDef>;
+  paneTemplates: ReadonlyMap<string, PaneTemplateDef>;
+  destroy(): void;
+}
+
+export interface PaneCatalogEntry {
+  token: string;
+  label: string;
+  description: string;
+  paneId: string;
+  paneName: string;
+  templateId?: string;
+  shortcut?: string;
+  argKind?: string;
+  argPlaceholder?: string;
+  keywords: string[];
+  defaultSettings: Record<string, unknown>;
+}
+
+export function buildTemplateContext(context: MarketContext, symbol: string | null) {
+  return {
+    config: context.config,
+    layout: context.config.layout,
+    focusedPaneId: null,
+    activeTicker: symbol,
+    activeCollectionId: null,
+  };
+}
+
+function registerResolverToken(
+  lookup: Map<string, PaneTemplateDef | PaneDef>,
+  token: string | undefined,
+  value: PaneTemplateDef | PaneDef,
+) {
+  if (!token) return;
+  const normalized = normalizeLookupToken(token);
+  if (!normalized || lookup.has(normalized)) return;
+  lookup.set(normalized, value);
+}
+
+export function buildPaneFunctionLookup(registry: PaneFunctionCatalog): Map<string, PaneTemplateDef | PaneDef> {
+  const lookup = new Map<string, PaneTemplateDef | PaneDef>();
+  for (const template of registry.paneTemplates.values()) {
+    registerResolverToken(lookup, template.shortcut?.prefix, template);
+    registerResolverToken(lookup, template.id, template);
+    registerResolverToken(lookup, template.label, template);
+    for (const keyword of template.keywords ?? []) registerResolverToken(lookup, keyword, template);
+  }
+
+  for (const pane of registry.panes.values()) {
+    registerResolverToken(lookup, pane.id, pane);
+    registerResolverToken(lookup, pane.name, pane);
+  }
+
+  const financialTemplate = registry.paneTemplates.get("financial-analysis-pane");
+  if (financialTemplate) {
+    lookup.set(normalizeLookupToken("financials"), financialTemplate);
+    lookup.set(normalizeLookupToken("financial-statements"), financialTemplate);
+    lookup.set(normalizeLookupToken("financial-statement"), financialTemplate);
+  }
+
+  return lookup;
+}
+
+function sampleArgForTemplate(template: PaneTemplateDef): string {
+  switch (template.shortcut?.argKind) {
+    case "ticker":
+      return "AAPL";
+    case "ticker-list":
+      return "AAPL,MSFT";
+    case "text":
+      return "sample";
+    default:
+      return "";
+  }
+}
+
+function formatCatalogSettings(settings: Record<string, unknown>): string {
+  const entries = Object.entries(settings)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${key}=${String(value)}`);
+  return entries.length > 0 ? entries.join(", ") : "none";
+}
+
+async function buildTemplateCatalogEntry(
+  template: PaneTemplateDef,
+  pane: PaneDef,
+  context: MarketContext,
+): Promise<PaneCatalogEntry> {
+  const sampleArg = sampleArgForTemplate(template);
+  const createOptions: PaneTemplateCreateOptions | undefined = buildCreateOptions(template, sampleArg);
+  const primarySymbol = createOptions?.symbol ?? createOptions?.symbols?.[0] ?? null;
+  let defaultSettings: Record<string, unknown> = {};
+
+  if (template.createInstance) {
+    try {
+      const spec = await template.createInstance(buildTemplateContext(context, primarySymbol), createOptions);
+      defaultSettings = spec?.settings ?? {};
+    } catch {
+      defaultSettings = {};
+    }
+  }
+
+  return {
+    token: template.shortcut?.prefix ?? template.id,
+    label: template.label,
+    description: template.description,
+    paneId: pane.id,
+    paneName: pane.name,
+    templateId: template.id,
+    shortcut: template.shortcut?.prefix,
+    argKind: template.shortcut?.argKind,
+    argPlaceholder: template.shortcut?.argPlaceholder,
+    keywords: template.keywords ?? [],
+    defaultSettings,
+  };
+}
+
+export async function buildPaneCatalogEntries(
+  registry: PaneFunctionCatalog,
+  context: MarketContext,
+): Promise<PaneCatalogEntry[]> {
+  const entries: PaneCatalogEntry[] = [];
+  const templatedPaneIds = new Set<string>();
+
+  for (const template of registry.paneTemplates.values()) {
+    const pane = registry.panes.get(template.paneId);
+    if (!pane) continue;
+    templatedPaneIds.add(pane.id);
+    entries.push(await buildTemplateCatalogEntry(template, pane, context));
+  }
+
+  for (const pane of registry.panes.values()) {
+    if (templatedPaneIds.has(pane.id)) continue;
+    entries.push({
+      token: pane.id,
+      label: pane.name,
+      description: `Open the ${pane.name} pane.`,
+      paneId: pane.id,
+      paneName: pane.name,
+      keywords: [],
+      defaultSettings: {},
+    });
+  }
+
+  return entries.sort((left, right) => left.token.localeCompare(right.token));
+}
+
+function paneCatalogSearchScore(entry: PaneCatalogEntry, query: string): number {
+  const terms = query.toLowerCase().split(/\s+/).map((term) => term.trim()).filter(Boolean);
+  if (terms.length === 0) return 1;
+
+  const exactTokens = [
+    entry.token,
+    entry.shortcut,
+    entry.templateId,
+    entry.paneId,
+  ].filter((value): value is string => !!value).map((value) => normalizeLookupToken(value));
+  const searchable = [
+    entry.token,
+    entry.label,
+    entry.description,
+    entry.paneId,
+    entry.paneName,
+    entry.templateId,
+    entry.shortcut,
+    entry.argKind,
+    entry.argPlaceholder,
+    ...entry.keywords,
+    ...Object.keys(entry.defaultSettings),
+  ].filter((value): value is string => !!value).join(" ").toLowerCase();
+
+  let score = searchable.includes(query.toLowerCase()) ? 4 : 0;
+  for (const term of terms) {
+    const normalized = normalizeLookupToken(term);
+    if (exactTokens.includes(normalized)) {
+      score += 8;
+    } else if (searchable.includes(term)) {
+      score += 2;
+    } else if (searchable.includes(normalized)) {
+      score += 1;
+    } else {
+      return 0;
+    }
+  }
+
+  return score;
+}
+
+export function filterPaneCatalogEntries(entries: PaneCatalogEntry[], query: string): PaneCatalogEntry[] {
+  return entries
+    .map((entry) => ({ entry, score: paneCatalogSearchScore(entry, query) }))
+    .filter(({ score }) => score > 0)
+    .sort((left, right) => right.score - left.score || left.entry.token.localeCompare(right.entry.token))
+    .map(({ entry }) => entry);
+}
+
+export function renderPaneCatalogReport(entries: PaneCatalogEntry[], args: ParsedPaneCatalogArgs): string {
+  const shown = entries.slice(0, args.limit);
+  const lines = [
+    "Gloomberb Function Catalog",
+    "",
+    "Use:",
+    "  gloomberb fn <shortcut-or-pane> [argument] [--key value]",
+    "  gloomberb shot <shortcut-or-pane> [argument] [--output path] [--key value]",
+    "",
+    args.query
+      ? `Matches for "${args.query}" (${shown.length}${entries.length > shown.length ? ` of ${entries.length}` : ""})`
+      : `Available pane functions (${shown.length}${entries.length > shown.length ? ` of ${entries.length}` : ""})`,
+    "",
+  ];
+
+  if (shown.length === 0) {
+    lines.push("No matching pane functions.");
+    return lines.join("\n");
+  }
+
+  for (const entry of shown) {
+    const arg = entry.argPlaceholder ? `<${entry.argPlaceholder}>` : entry.argKind ? `<${entry.argKind}>` : "[argument]";
+    lines.push(`${entry.token} | ${entry.label}`);
+    lines.push(`  Description: ${entry.description}`);
+    lines.push(`  Pane: ${entry.paneId} (${entry.paneName})`);
+    if (entry.templateId) lines.push(`  Template: ${entry.templateId}`);
+    if (entry.shortcut) lines.push(`  Shortcut: ${entry.shortcut}`);
+    if (entry.argKind) lines.push(`  Argument: ${entry.argKind}${entry.argPlaceholder ? ` (${entry.argPlaceholder})` : ""}`);
+    if (entry.keywords.length > 0) lines.push(`  Keywords: ${entry.keywords.join(", ")}`);
+    lines.push(`  Defaults: ${formatCatalogSettings(entry.defaultSettings)}`);
+    lines.push(`  Examples: gloomberb fn ${entry.token} ${arg} | gloomberb shot ${entry.token} ${arg} --output /tmp/${entry.token.toLowerCase()}.png`);
+    lines.push("");
+  }
+
+  lines.push("Generic screenshot state options: --tab <id>, --activeTabId <id>, --state key=value, --state.<key> value.");
+  return lines.join("\n").trimEnd();
+}

package/src/cli/pane-functions/data.ts

@@ -0,0 +1,78 @@
+import type { TickerFinancials } from "../../types/financials";
+import type { TickerRecord } from "../../types/ticker";
+import { LEGACY_TICKER_DETAIL_PANE_ID } from "../../types/config";
+import { normalizeTickerInput } from "../../tickers/search";
+import type { MarketContext } from "../types";
+import { cleanTickerInput } from "./options";
+import type { ResolvedPaneFunction } from "./resolver";
+
+const SHOT_PRICE_HISTORY_RANGE = "5Y" as const;
+const FINANCIAL_ANALYSIS_PANE_ID = "financial-analysis";
+const FINANCIAL_ANALYSIS_TEMPLATE_ID = "financial-analysis-pane";
+
+export async function fetchTickerFinancials(
+  context: MarketContext,
+  symbol: string,
+): Promise<{ tickerFile: TickerRecord | null; financials: TickerFinancials }> {
+  const normalized = cleanTickerInput(symbol);
+  const tickerFile = await context.store.loadTicker(normalized);
+  const exchange = tickerFile?.metadata.exchange ?? "";
+  const financials = await context.dataProvider.getTickerFinancials(normalized, exchange);
+  return { tickerFile, financials };
+}
+
+export async function withShotPriceHistory(
+  context: MarketContext,
+  symbol: string,
+  tickerFile: TickerRecord | null,
+  financials: TickerFinancials,
+): Promise<TickerFinancials> {
+  if (financials.priceHistory?.length) return financials;
+  const exchange = tickerFile?.metadata.exchange
+    ?? financials.quote?.listingExchangeName
+    ?? financials.quote?.exchangeName
+    ?? "";
+  try {
+    const priceHistory = await context.dataProvider.getPriceHistory(symbol, exchange, SHOT_PRICE_HISTORY_RANGE);
+    return priceHistory.length > 0 ? { ...financials, priceHistory } : financials;
+  } catch {
+    return financials;
+  }
+}
+
+export function requireSymbol(resolved: ResolvedPaneFunction, rawArg: string): string {
+  const symbol = resolved.createOptions?.symbol ?? normalizeTickerInput(null, cleanTickerInput(rawArg));
+  if (!symbol) throw new Error(`Usage: gloomberb fn ${resolved.token} <symbol>`);
+  return symbol;
+}
+
+export function isFinancialAnalysisFunction(resolved: ResolvedPaneFunction): boolean {
+  if (resolved.pane.id === FINANCIAL_ANALYSIS_PANE_ID) return true;
+  if (resolved.template?.id === FINANCIAL_ANALYSIS_TEMPLATE_ID) return true;
+  return resolved.pane.id === LEGACY_TICKER_DETAIL_PANE_ID
+    && resolved.instance.settings?.lockedTabId === "financials";
+}
+
+export function createFallbackTicker(symbol: string, financials: TickerFinancials | null, context: MarketContext): TickerRecord {
+  const quote = financials?.quote;
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange: quote?.listingExchangeName ?? quote?.exchangeName ?? "",
+      currency: quote?.currency ?? context.config.baseCurrency,
+      name: quote?.name ?? symbol,
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+export function collectShotSymbols(resolved: ResolvedPaneFunction, rawArg: string): string[] {
+  const symbols = resolved.createOptions?.symbols?.length
+    ? resolved.createOptions.symbols
+    : [resolved.createOptions?.symbol ?? normalizeTickerInput(null, cleanTickerInput(rawArg))].filter((symbol): symbol is string => !!symbol);
+  return [...new Set(symbols.map(cleanTickerInput).filter(Boolean))];
+}

package/src/cli/pane-functions/discovery.ts

@@ -0,0 +1,113 @@
+import type { GloomPlugin, PaneDef, PaneTemplateDef } from "../../types/plugin";
+import type { MarketContext } from "../types";
+import type { PaneFunctionCatalog } from "./catalog";
+
+export async function createPaneCatalog(context: MarketContext, plugins: GloomPlugin[]): Promise<PaneFunctionCatalog> {
+  const panes = new Map<string, PaneDef>();
+  const paneTemplates = new Map<string, PaneTemplateDef>();
+  const setupPlugins: GloomPlugin[] = [];
+  const fakePersistence = createFakePluginPersistence();
+  // Collect setup-registered panes without booting the real plugin runtime or polling engines.
+  const fakeContext = {
+    registerPane: (pane: PaneDef) => panes.set(pane.id, pane),
+    registerPaneTemplate: (template: PaneTemplateDef) => paneTemplates.set(template.id, template),
+    registerCommand: () => {},
+    registerColumn: () => {},
+    registerBroker: () => {},
+    registerCapability: () => {},
+    registerTickerResearchTab: () => {},
+    registerShortcut: () => {},
+    registerTickerAction: () => {},
+    registerContextMenuProvider: () => {},
+    watchNewsQuery: () => () => {},
+    getData: () => null,
+    getTicker: () => null,
+    getConfig: () => context.config,
+    getPaneDef: (paneId: string) => panes.get(paneId),
+    marketData: context.dataProvider,
+    tickerRepository: context.store,
+    persistence: fakePersistence,
+    log: {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    },
+    resume: {
+      getState: () => null,
+      setState: () => {},
+      deleteState: () => {},
+      getPaneState: () => null,
+      setPaneState: () => {},
+      deletePaneState: () => {},
+    },
+    configState: {
+      get: () => null,
+      set: async () => {},
+      delete: async () => {},
+      keys: () => [],
+    },
+    paneSettings: {
+      get: () => null,
+      set: async () => {},
+      delete: async () => {},
+    },
+    createBrokerInstance: async () => {
+      throw new Error("Broker creation is unavailable during CLI pane discovery.");
+    },
+    updateBrokerInstance: async () => {},
+    syncBrokerInstance: async () => {},
+    removeBrokerInstance: async () => {},
+    selectTicker: () => {},
+    switchPanel: () => {},
+    switchTab: () => {},
+    openCommandBar: () => {},
+    showPane: () => {},
+    createPaneFromTemplate: () => {},
+    hidePane: () => {},
+    focusPane: () => {},
+    pinTicker: () => {},
+    navigateTicker: () => {},
+    openPaneSettings: () => {},
+    on: () => () => {},
+    emit: () => {},
+    notify: () => {},
+  };
+
+  for (const plugin of plugins) {
+    for (const pane of plugin.panes ?? []) panes.set(pane.id, pane);
+    for (const template of plugin.paneTemplates ?? []) paneTemplates.set(template.id, template);
+    if (plugin.setup) {
+      setupPlugins.push(plugin);
+      await plugin.setup(fakeContext as never);
+    }
+  }
+
+  return {
+    panes,
+    paneTemplates,
+    destroy() {
+      for (const plugin of setupPlugins.reverse()) {
+        plugin.dispose?.();
+      }
+    },
+  };
+}
+
+function createFakePluginPersistence() {
+  const resources = new Map<string, unknown>();
+  return {
+    getState: () => null,
+    setState: () => {},
+    deleteState: () => {},
+    getResource: (kind: string, key: string) => resources.get(`${kind}:${key}`) ?? null,
+    setResource: (kind: string, key: string, value: unknown) => {
+      const entry = { value, updatedAt: Date.now(), expiresAt: null, provenance: null };
+      resources.set(`${kind}:${key}`, entry);
+      return entry;
+    },
+    deleteResource: (kind: string, key: string) => {
+      resources.delete(`${kind}:${key}`);
+    },
+  };
+}

package/src/cli/pane-functions/index.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+import { paneFunctionTestInternals } from "./index";
+
+const {
+  parsePaneFunctionArgs,
+  parsePaneCatalogArgs,
+  normalizeLookupToken,
+  parseArgumentsOption,
+  optionPaneState,
+  filterPaneCatalogEntries,
+  renderPaneCatalogReport,
+} = paneFunctionTestInternals;
+
+describe("pane function CLI args", () => {
+  test("parses target, argument, output, size, and pane options", () => {
+    const parsed = parsePaneFunctionArgs([
+      "FA",
+      "$NVDA",
+      "--period",
+      "quarterly",
+      "--statement=balance",
+      "--output",
+      "/tmp/fa-nvda.png",
+      "--width",
+      "900",
+      "--height=700",
+    ]);
+
+    expect(parsed.target).toBe("FA");
+    expect(parsed.arg).toBe("$NVDA");
+    expect(parsed.outputPath).toBe("/tmp/fa-nvda.png");
+    expect(parsed.width).toBe(900);
+    expect(parsed.height).toBe(700);
+    expect(parsed.options).toEqual({
+      period: "quarterly",
+      statement: "balance",
+    });
+  });
+
+  test("normalizes pane ids and shortcuts into one lookup form", () => {
+    expect(normalizeLookupToken("comparison-chart-pane")).toBe("comparisonchartpane");
+    expect(normalizeLookupToken("CMP")).toBe("cmp");
+    expect(normalizeLookupToken("$FA")).toBe("fa");
+  });
+
+  test("expands --arguments key-value pairs", () => {
+    expect(parseArgumentsOption("range-preset=1Y, axis_mode=percent")).toEqual({
+      rangePreset: "1Y",
+      axisMode: "percent",
+    });
+  });
+
+  test("maps generic screenshot options into pane runtime state", () => {
+    expect(optionPaneState({
+      activeTab: "chart",
+      state: "cursorSymbol=NVDA,customFlag=true",
+    })).toEqual({
+      activeTabId: "chart",
+      cursorSymbol: "NVDA",
+      customFlag: true,
+    });
+  });
+
+  test("maps financial statement options into reusable pane state", () => {
+    expect(optionPaneState({
+      statement: "balance sheet",
+      period: "quarterly",
+    })).toEqual({
+      financialSubTab: "balance",
+      financialPeriod: "quarterly",
+    });
+  });
+
+  test("parses catalog queries and limit options", () => {
+    expect(parsePaneCatalogArgs(["chart", "price", "--limit", "3"])).toEqual({
+      query: "chart price",
+      limit: 3,
+    });
+  });
+
+  test("searches and renders pane catalog entries", () => {
+    const matches = filterPaneCatalogEntries([
+      {
+        token: "GP",
+        label: "Graph Price",
+        description: "Open a ticker detail pane locked to a price chart.",
+        paneId: "ticker-detail",
+        paneName: "Detail",
+        templateId: "graph-price-pane",
+        shortcut: "GP",
+        argKind: "ticker",
+        argPlaceholder: "ticker",
+        keywords: ["gp", "graph", "price", "chart"],
+        defaultSettings: { lockedTabId: "chart", chartRangePreset: "5Y" },
+      },
+      {
+        token: "FA",
+        label: "Financial Analysis",
+        description: "Open a ticker detail pane locked to financial statements.",
+        paneId: "ticker-detail",
+        paneName: "Detail",
+        templateId: "financial-analysis-pane",
+        shortcut: "FA",
+        argKind: "ticker",
+        argPlaceholder: "ticker",
+        keywords: ["fa", "financial", "analysis", "statements"],
+        defaultSettings: { lockedTabId: "financials" },
+      },
+    ], "price chart");
+
+    expect(matches.map((entry) => entry.token)).toEqual(["GP"]);
+    expect(renderPaneCatalogReport(matches, { query: "price chart", limit: 10 })).toContain("gloomberb shot GP <ticker>");
+  });
+});