gloomberb 0.18.3 → 0.18.4

package/src/cli/pane-functions/screenshot-render.ts

@@ -0,0 +1,316 @@
+import { logFailure } from "../../utils/log-failure";
+import { apiClient } from "../../api-client";
+import { loadResolvedHeadlessPaneModel, reportCoverage, reportGaps, type LoadedHeadlessPaneModel } from "./headless";
+import { dirname } from "path";
+import { mkdir } from "fs/promises";
+import type { Quote } from "../../types/financials";
+import { isRecord } from "../../utils/guards";
+import {
+  renderDesktopPaneScreenshot,
+  type DesktopPaneShotBridge,
+  type DesktopPaneShotPayload,
+  type DesktopPaneShotRenderResult,
+} from "../desktop-pane-shot";
+import type { ResolvedPaneFunction } from "./resolver";
+import type { MarketContext } from "../types";
+import type { RemoteUiNodeSnapshot } from "../../remote/types";
+import { declaredReportFreshness, renderedReportFreshness, renderedReportObservations } from "./report-notices";
+import {
+  captureStatusLine,
+  deriveCaptureReport,
+  deriveHeadlessFreshness,
+  deriveRenderedFreshness,
+  type CaptureReport,
+  type CaptureStatusLine,
+  type ReportFreshness,
+} from "./freshness";
+import { quotesFreshness } from "../freshness";
+import { paneFitsRows, shotMaxHeightCells, buildDesktopShotPayload } from "./screenshot-payload";
+import { resolveDesktopShotApiProxy, createDesktopShotBridge } from "./screenshot-bridge";
+import type { PaneScreenshotResult } from "./screenshot-types";
+import { assessPaneScreenshot } from "./screenshot-assessment";
+
+/** The bridge, keeping every quote it serves the page: what a pane that loads its own quotes (WEI) shows. */
+function recordBridgedQuotes(bridge: DesktopPaneShotBridge): { bridge: DesktopPaneShotBridge; quotes: Quote[] } {
+  const quotes: Quote[] = [];
+  const keep = (value: unknown) => {
+    if (isRecord(value) && typeof value.symbol === "string" && typeof value.price === "number") quotes.push(value as unknown as Quote);
+  };
+  return {
+    quotes,
+    bridge: {
+      ...bridge,
+      async marketData(operation, args) {
+        const result = await bridge.marketData(operation, args);
+        if (operation === "getQuote") keep(result);
+        if (operation === "getQuotesBatch" && Array.isArray(result)) {
+          for (const entry of result) keep(isRecord(entry) ? entry.quote : null);
+        }
+        return result;
+      },
+    },
+  };
+}
+
+/**
+ * How current a capture's data is (`captureStatusLine`). A pane that dates its
+ * view itself (the news wire's delay, FXC's rates) is taken at its word, and so
+ * is a report that says what its data is (EE's estimates, MDAY's study): the
+ * quotes the page loaded beside them do not date them. A pane that declares a
+ * status is never dated by the quotes it shows; otherwise those quotes date it,
+ * with their delay and where their markets stand. Then the pane's report, as
+ * `fn` ends; then what the rendered view carries. A function that opens one
+ * view of a pane hosting several declares it on its template (DDIS in Fixed
+ * Income), so its filings, not the issuer's stock quote, date the capture.
+ */
+export function shotFreshness(
+  resolved: Pick<ResolvedPaneFunction, "pane" | "template">,
+  payload: Pick<DesktopPaneShotPayload, "financials" | "instrumentFinancials">,
+  render: Pick<DesktopPaneShotRenderResult, "semanticUi" | "footerText" | "rows">,
+  bridgedQuotes: readonly Quote[],
+  report: CaptureReport | undefined,
+  now = Date.now(),
+): CaptureStatusLine {
+  const published = renderedReportFreshness(render.semanticUi ?? []);
+  const declared = { ...declaredReportFreshness(resolved), ...published };
+  const quotes = [
+    ...payload.financials.map(([, financials]) => financials.quote),
+    ...(payload.instrumentFinancials ?? []).map(({ financials }) => financials.quote),
+    ...bridgedQuotes,
+  ];
+  // A pane that publishes the observations behind its figures (FXC's rates) dates itself.
+  const observed = renderedReportObservations(render.semanticUi ?? []);
+  const quoted = declared.status || observed.length > 0
+    ? undefined
+    : quotesFreshness(quotes, declared.source ? { source: declared.source } : undefined, now);
+  return captureStatusLine({
+    report,
+    selfDated: Object.keys(published).length > 0 || observed.length > 0,
+    quoted,
+    rendered: () => deriveRenderedFreshness(declared, {
+      footerText: render.footerText ?? "",
+      cellTimes: render.rows.flatMap((row) => row.cells.flatMap((cell) => (cell.instant ? [cell.instant] : []))),
+      observed,
+    }, now),
+  });
+}
+
+/**
+ * A capture's data dated as its `fn` report dates it, from the same loader:
+ * COT's weekly report, CHOKE's transits, GPU's prices. Undefined for a pane
+ * without a report, or when it did not load.
+ */
+async function reportShotFreshness(
+  resolved: Pick<ResolvedPaneFunction, "headless">,
+  loadModel: () => Promise<LoadedHeadlessPaneModel>,
+  now = Date.now(),
+): Promise<CaptureReport | undefined> {
+  if (!resolved.headless) return undefined;
+  try {
+    const loaded = await loadModel();
+    return deriveCaptureReport(loaded.definition, loaded.result, now);
+  } catch (error) {
+    logFailure("cli.screenshot", "Read screenshot report freshness failed")(error);
+    return undefined;
+  }
+}
+
+/** What a capture's report says about its own completeness (`fn`'s `complete`), as `reportCoverage` derives it. */
+export interface ShotReportCoverage {
+  complete: boolean;
+  unavailableSymbols: string[];
+  gaps?: string;
+}
+
+/**
+ * Whether the pane's report covers what was asked, loaded once with the
+ * capture's other uses of it. Undefined for a pane without a report, or when
+ * it did not load.
+ */
+export async function reportShotCoverage(
+  resolved: Pick<ResolvedPaneFunction, "headless">,
+  loadModel: () => Promise<LoadedHeadlessPaneModel>,
+): Promise<ShotReportCoverage | undefined> {
+  if (!resolved.headless) return undefined;
+  try {
+    const loaded = await loadModel();
+    const { complete, unavailableSymbols } = reportCoverage(loaded);
+    const gaps = reportGaps(loaded, deriveHeadlessFreshness(loaded.definition, loaded.result));
+    return { complete, unavailableSymbols, ...(gaps ? { gaps } : {}) };
+  } catch (error) {
+    logFailure("cli.screenshot", "Read screenshot report coverage failed")(error);
+    return undefined;
+  }
+}
+
+/**
+ * The capture's result with its report's completeness: a capture of a partial
+ * report is partial too, whatever the rendered view shows. Whether the image
+ * is fit to use stays what the render says.
+ */
+export function withReportCoverage(result: PaneScreenshotResult, coverage: ShotReportCoverage | undefined): PaneScreenshotResult {
+  if (!coverage || coverage.complete) return result;
+  return {
+    ...result,
+    complete: false,
+    unavailableSymbols: [...new Set([...result.unavailableSymbols, ...coverage.unavailableSymbols])],
+    ...(coverage.gaps ? { gaps: coverage.gaps } : {}),
+  };
+}
+
+/** How long a rendered capture waits for its report's freshness before dating itself without it. */
+const SHOT_REPORT_WAIT_MS = 20_000;
+
+/**
+ * The value of the report's `tab` option for the tab the capture shows, when
+ * it was asked for another: `DOE --tab all` draws Crude, so it is dated by
+ * Wednesday's petroleum report, not by Thursday's gas storage. Undefined when
+ * it shows the tab asked for.
+ */
+export function shownReportTab(
+  resolved: Pick<ResolvedPaneFunction, "headless" | "options">,
+  semanticUi: readonly RemoteUiNodeSnapshot[],
+): string | undefined {
+  const asked = resolved.options.tab;
+  const values = resolved.headless?.options?.find(({ key }) => key === "tab")?.values?.map(({ value }) => value) ?? [];
+  if (asked == null || values.length === 0) return undefined;
+  for (const node of semanticUi) {
+    const active = node.role === "tabs" ? node.metadata?.activeValue : undefined;
+    if (typeof active === "string" && values.includes(active)) return active === String(asked) ? undefined : active;
+  }
+  return undefined;
+}
+
+/** `pending`'s value, or undefined when it has not settled within `ms`; a later result is dropped. */
+function settledWithin<T>(pending: Promise<T>, ms: number): Promise<T | undefined> {
+  let cancel = () => {};
+  const expired = new Promise<undefined>((resolve) => {
+    const timer = setTimeout(() => resolve(undefined), ms);
+    cancel = () => clearTimeout(timer);
+  });
+  return Promise.race([pending, expired]).finally(() => cancel());
+}
+
+/** One load of the pane's report per capture, shared by the payload and the status line. */
+function onceLoader(load: () => Promise<LoadedHeadlessPaneModel>): () => Promise<LoadedHeadlessPaneModel> {
+  let pending: Promise<LoadedHeadlessPaneModel> | undefined;
+  return () => (pending ??= load());
+}
+
+export async function renderDesktopShot({
+  resolved,
+  context,
+  rawArg,
+  outputPath,
+  width,
+  height,
+  theme,
+  scale,
+  watermark,
+  statusLine = false,
+  fitRows = false,
+  fitReader = false,
+  maxHeightCells,
+  options,
+  captureImage = true,
+  onStalledReport,
+}: {
+  resolved: ResolvedPaneFunction;
+  context: MarketContext;
+  rawArg: string;
+  outputPath: string;
+  width: number;
+  height: number;
+  theme?: string | null;
+  scale?: number;
+  watermark?: string | null;
+  /** Draw the dated status line in the capture's footer. Reports and `--no-status` leave it out. */
+  statusLine?: boolean;
+  /** No `--height` was asked for: a pane that fits its rows (FUT) grows to show them all. */
+  fitRows?: boolean;
+  /** A pane whose reader has a page open grows to show all of its text (a report's, which saves no image). */
+  fitReader?: boolean;
+  /** How tall a pane that fits its rows or its reader may grow, in cells, where the height limit of a saved image does not apply. */
+  maxHeightCells?: number;
+  options: Record<string, string | true>;
+  captureImage?: boolean;
+  /**
+   * Called when the report behind the status line was still loading at the
+   * wait's end: the load was aborted, but a loader that ignores the signal
+   * may keep the process alive.
+   */
+  onStalledReport?: () => void;
+}): Promise<PaneScreenshotResult> {
+  if (captureImage) await mkdir(dirname(outputPath), { recursive: true });
+  const apiProxy = resolveDesktopShotApiProxy(context);
+  const previousSessionToken = apiClient.getSessionToken();
+  let payload: DesktopPaneShotPayload;
+  let render: DesktopPaneShotRenderResult;
+  let freshness: ReportFreshness | undefined;
+  let coverage: Promise<ShotReportCoverage | undefined> | undefined;
+  let covered: ShotReportCoverage | undefined;
+  // A report still loading when the status line stops waiting for it is
+  // aborted, and the caller told: a loader that ignores the signal goes on.
+  const reportLoads = new AbortController();
+  let loading = 0;
+  const loadReport = (target: ResolvedPaneFunction) => {
+    loading += 1;
+    return loadResolvedHeadlessPaneModel(target, context, rawArg, reportLoads.signal).finally(() => { loading -= 1; });
+  };
+  const abandonReports = () => {
+    if (loading === 0 || reportLoads.signal.aborted) return;
+    reportLoads.abort(new Error("The capture stopped waiting for its report."));
+    onStalledReport?.();
+  };
+  apiClient.setSessionToken(apiProxy.sessionToken);
+  try {
+    const loadModel = onceLoader(() => loadReport(resolved));
+    payload = await buildDesktopShotPayload(
+      resolved,
+      context,
+      rawArg,
+      options,
+      width,
+      height,
+      theme ?? null,
+      scale ?? 1,
+      watermark ?? null,
+      loadModel,
+    );
+    if (statusLine && captureImage) payload.statusLine = true;
+    const fitRoles = [
+      ...(fitRows && paneFitsRows(resolved) ? ["data-table-body-scroll"] : []),
+      ...(fitReader && resolved.pane.shotFitsReader ? ["detail-scroll-body"] : []),
+    ];
+    if (fitRoles.length > 0) {
+      payload.maxHeightCells = maxHeightCells ?? shotMaxHeightCells(scale ?? 1);
+      payload.fitRoles = fitRoles;
+    }
+    // Loads while the page renders.
+    const report = payload.statusLine ? reportShotFreshness(resolved, loadModel) : undefined;
+    // The same load says whether the report is complete, with or without a status line.
+    coverage = captureImage ? reportShotCoverage(resolved, loadModel) : undefined;
+    const recorded = recordBridgedQuotes(createDesktopShotBridge(context));
+    const shotPayload = payload;
+    render = await renderDesktopPaneScreenshot(payload, outputPath, apiProxy, {
+      captureImage,
+      bridge: recorded.bridge,
+      statusLine: async (rendered) => {
+        const tab = report && shownReportTab(resolved, rendered.semanticUi);
+        const shown = tab ? reportShotFreshness(resolved, () => loadReport({ ...resolved, options: { ...resolved.options, tab } })) : report;
+        const line = shotFreshness(resolved, shotPayload, rendered, recorded.quotes, shown && await settledWithin(shown, SHOT_REPORT_WAIT_MS));
+        abandonReports();
+        freshness = line.freshness;
+        return { variants: line.variants, dates: line.dates };
+      },
+    });
+    covered = coverage && await settledWithin(coverage, SHOT_REPORT_WAIT_MS);
+  } finally {
+    apiClient.setSessionToken(previousSessionToken);
+    abandonReports();
+  }
+  const renderedInstance = payload.config.layout.instances.find(({ instanceId }) => instanceId === payload.paneId);
+  if (renderedInstance) resolved = { ...resolved, instance: renderedInstance };
+  const assessed = withReportCoverage(assessPaneScreenshot(resolved, payload, render, rawArg, outputPath), covered);
+  return freshness ? { ...assessed, freshness } : assessed;
+}

package/src/cli/pane-functions/screenshot-types.ts

@@ -0,0 +1,162 @@
+import type { DesktopPaneShotRenderResult } from "../desktop-pane-shot";
+import type { ResolvedPaneFunction } from "./resolver";
+import type { FundamentalPeriod } from "../../time-series/reporting";
+import type { PaneScreenshotEvidence } from "./screenshot-evidence";
+import type { ReportFreshness } from "./freshness";
+import type { PaneScreenshotFinancialRatioEvidence } from "./financial-ratio-shot";
+
+export interface PaneScreenshotExpectedSelection {
+  control: "metric" | "statement" | "ratio" | "period";
+  value?: string;
+  label?: string;
+}
+
+export interface PaneScreenshotChartPointEvidence {
+  date: string;
+  close: number;
+}
+
+export interface PaneScreenshotChartSeriesEvidence {
+  symbol: string;
+  pointCount: number;
+  first: PaneScreenshotChartPointEvidence | null;
+  last: PaneScreenshotChartPointEvidence | null;
+  projectionBaseValue?: number | null;
+  projectionLatestRawValue?: number | null;
+  projectionLatestValue?: number | null;
+}
+
+export interface PaneScreenshotExpectedChartEvidence {
+  kind: "stock-price" | "price-comparison" | "chart-composer";
+  symbols: string[];
+  rangePreset: string;
+  axisMode?: string;
+  resolution?: string;
+  sourceSeries?: PaneScreenshotChartSeriesEvidence[];
+  baseSeries?: Array<{
+    id: string;
+    sourceKind: "security" | "economic" | "capability";
+    symbol?: string;
+    fieldId?: string;
+    economicSeriesId?: string;
+    capabilityId?: string;
+    providerSeriesId?: string;
+    first?: { date: string; value: number | null } | null;
+    last?: { date: string; value: number | null } | null;
+    style: string;
+    transform: string;
+    panelId: string;
+    visible: boolean;
+  }>;
+}
+
+interface PaneScreenshotPriceComparisonEvidence {
+  kind: "price-comparison";
+  symbols: string[];
+  range: string;
+  series: Array<{
+    symbol: string;
+    base: { date: string; value: number };
+    latest: { date: string; value: number };
+    returnPercent: number;
+  }>;
+}
+
+interface PaneScreenshotPriceSeriesEvidence {
+  kind: "price-series";
+  symbol: string;
+  range: string;
+  pointCount: number;
+  first: PaneScreenshotChartPointEvidence;
+  last: PaneScreenshotChartPointEvidence;
+  resolution?: string;
+  sessionDates?: string[];
+}
+
+interface PaneScreenshotFundamentalSeriesEvidence {
+  kind: "fundamental-series";
+  metric: string;
+  period: FundamentalPeriod;
+  series: Array<{
+    symbol: string;
+    rows: Array<{ date: string; value: number }>;
+  }>;
+}
+
+interface PaneScreenshotFinancialStatementEvidence {
+  kind: "financial-statement";
+  symbol: string;
+  statement: string;
+  period: FundamentalPeriod;
+  latest: {
+    date: string;
+    metrics: Array<{
+      id: string;
+      key: string;
+      label: string;
+      value: number;
+    }>;
+  };
+}
+
+export type PaneScreenshotDataEvidence =
+  | PaneScreenshotPriceSeriesEvidence
+  | PaneScreenshotPriceComparisonEvidence
+  | PaneScreenshotFundamentalSeriesEvidence
+  | PaneScreenshotFinancialStatementEvidence
+  | PaneScreenshotFinancialRatioEvidence
+  | PaneScreenshotEvidence;
+
+export interface PaneScreenshotReadinessSignals {
+  rowCount: number;
+  loadingStateDetected: boolean;
+  errorStateDetected: boolean;
+  emptyStateDetected: boolean;
+  complete: boolean;
+  semanticMismatch: boolean;
+  requiresStructuredDataEvidence: boolean;
+  hasStructuredDataEvidence: boolean;
+}
+
+export interface PaneScreenshotResult {
+  kind: "pane-screenshot";
+  target: string;
+  capability: {
+    id: string;
+    botSafe: boolean;
+    outputKind: string;
+    reportReadiness: ResolvedPaneFunction["capability"]["reportReadiness"];
+    screenshotReadiness: ResolvedPaneFunction["capability"]["screenshotReadiness"];
+  };
+  symbols: string[];
+  options: Record<string, string | number | boolean>;
+  rowCount: number;
+  empty: boolean;
+  complete: boolean;
+  unavailableSymbols: string[];
+  semanticMismatch: boolean;
+  usable: boolean;
+  unusableReason: string | null;
+  dataEvidence: PaneScreenshotDataEvidence | null;
+  /** What the pane says its view leaves out, such as OMON's "21 of 145 strikes". */
+  notices?: string[];
+  /**
+   * For a pane that grows to show every row (FUT): how many of the rows its
+   * table reports the image shows, section headers left out. `shown` is less
+   * than `total` when the height limit or `--height` cut the board.
+   */
+  tableRows?: { shown: number; total: number };
+  /** What the pane's report leaves out when it is not complete, as `fn` words it: `2 stale`. */
+  gaps?: string;
+  /** How current the captured data is, as the capture's status line says it; absent with `--no-status`. */
+  freshness?: ReportFreshness;
+  outputPath: string;
+  render: DesktopPaneShotRenderResult & {
+    expectedText: string[];
+    missingExpectedText: string[];
+    expectedSelections: PaneScreenshotExpectedSelection[];
+    missingExpectedSelections: PaneScreenshotExpectedSelection[];
+    expectedChart: PaneScreenshotExpectedChartEvidence | null;
+    chartEvidenceMismatches: string[];
+  };
+}

package/src/cli/pane-functions/shot-options.ts

@@ -1,5 +1,5 @@
 import { typoDistance } from "../../utils/typo-distance";
-import { findCapabilityOption } from "./capabilities";
+import { findCapabilityOption, optionFlag } from "./capabilities";
 import type { ResolvedPaneFunction } from "./resolver";
 
 /** An argument as a shell reads it back: bare when it is one word, in quotes when it is not. */
@@ -40,13 +40,18 @@ export function shotOptionRefusal(
   options: Record<string, string | true>,
   { explain = false }: { explain?: boolean } = {},
 ): string | null {
-  const report = (...flags: string[]) => ["gloomberb fn", resolved.token, rawArgument.trim() && shellWord(rawArgument.trim()), ...flags]
+  const report = (...flags: string[]) => ["gloom fn", resolved.token, rawArgument.trim() && shellWord(rawArgument.trim()), ...flags]
     .filter(Boolean).join(" ");
   const given: Array<[string, string | true]> = [...explain ? [["explain", true] as [string, true]] : [], ...Object.entries(options)];
+  // The report is run with every option only it reads, so HP's `--from 2007 --to 2009` keeps its end.
+  const reportFlags = given.flatMap(([key, value]) => {
+    const option = findCapabilityOption(resolved.capability, key);
+    return option?.shot ? [optionFlag(option.key), value === true ? "" : shellWord(value)] : [];
+  });
   for (const [key, value] of given) {
     const option = findCapabilityOption(resolved.capability, key);
     if (option?.shot) {
-      return `${resolved.token}'s pane does not draw --${option.key}: it ${option.shot.reportOnly}. Drop it from shot, or run the report: ${report(`--${option.key}`, value === true ? "" : shellWord(value))}`;
+      return `${resolved.token}'s pane does not draw --${option.key}: it ${option.shot.reportOnly}. Drop it from shot, or run the report: ${report(...reportFlags)}`;
     }
     if (option) continue;
     const row = GLOBAL_ROW_OPTIONS[key];

package/src/cli/peso-dollar-rates.ts

@@ -0,0 +1,79 @@
+import type { Quote } from "../types/financials";
+import type { QuoteBatchResult, QuoteSubscriptionTarget } from "../types/data-provider";
+import {
+  bymaDollarLineKeys, formatPairRate, listingDepositaryPair, pairPriceInput, pairTimeText, pesoImpliedRates,
+  PESO_REFERENCE_RECEIPT, spotRateKind, type ImpliedDollarRate,
+} from "../market-data/depositary-pair";
+
+/** Galicia's peso line, which the receipt and both Buenos Aires dollar lines are compared with. */
+const PESO_REFERENCE_HOME = "GGAL.BA";
+
+export interface PesoDollarRates {
+  /** `official wholesale`: what the served USD/ARS rate is. */
+  spotKind: string;
+  rates: ImpliedDollarRate[];
+  /** The listings no price came back for. */
+  missing: string[];
+}
+
+/** Whether a pair is the peso against the dollar, either way round. */
+export function isPesoDollarPair(currency: string, baseCurrency: string): boolean {
+  const codes = new Set([currency, baseCurrency]);
+  return codes.has("ARS") && codes.has("USD");
+}
+
+/**
+ * The peso's market dollar rates beside the official one: the CCL rate
+ * Galicia's receipt implies against its peso line, and the CCL and MEP rates
+ * of its Buenos Aires C and D lines. The four quotes are read in one batch,
+ * through the same quote path as `quote`. The receipt's ratio is the one
+ * Gloom Cloud serves on it; without it that row is left out.
+ */
+export async function loadPesoDollarRates(
+  getQuotesBatch: (targets: QuoteSubscriptionTarget[]) => Promise<QuoteBatchResult[]>,
+): Promise<PesoDollarRates> {
+  const lines = bymaDollarLineKeys(PESO_REFERENCE_HOME)!;
+  const keys = [PESO_REFERENCE_RECEIPT, PESO_REFERENCE_HOME, lines.ccl, lines.mep];
+  const results = await getQuotesBatch(keys.map((symbol) => ({ symbol, exchange: "" })));
+  const quotes = new Map<string, Quote | null>(keys.map((key, index) => [key, results[index]?.quote ?? null]));
+  const receiptQuote = quotes.get(PESO_REFERENCE_RECEIPT) ?? null;
+  const pair = listingDepositaryPair({ quote: receiptQuote });
+  const pairsWithHome = pair?.ordinary.some((line) => line.toUpperCase() === PESO_REFERENCE_HOME) ?? false;
+  const input = (key: string) => pairPriceInput(key, quotes.get(key));
+  // A ratio not on record leaves the receipt's rate out rather than guess it.
+  const rates = pesoImpliedRates(pair && pairsWithHome ? pair.ratio : null, {
+    home: input(PESO_REFERENCE_HOME),
+    receipt: input(PESO_REFERENCE_RECEIPT),
+    ccl: input(lines.ccl),
+    mep: input(lines.mep),
+  });
+  return { spotKind: spotRateKind("ARS")!, rates, missing: keys.filter((key) => !input(key)) };
+}
+
+/** `CCL via GGAL ADR  1,651.28  = 6,260 × 10 / 37.91 (GGAL.BA Fri 23 Oct 20:00 UTC, GGAL Fri 23 Oct 20:00 UTC)`. */
+export function pesoDollarRateLines(report: PesoDollarRates, now = Date.now()): string[] {
+  if (report.rates.length === 0) return [];
+  const labelWidth = Math.max(...report.rates.map((rate) => rate.label.length));
+  const valueWidth = Math.max(...report.rates.map((rate) => formatPairRate(rate.rate).length));
+  return [
+    "Market rates implied by Buenos Aires prices, pesos per dollar:",
+    ...report.rates.map((rate) => {
+      const times = rate.inputs.map((input) => `${input.symbol} ${input.observedAt == null ? "undated" : pairTimeText(input.observedAt, now)}${input.open ? "" : ", closed"}`);
+      return `  ${rate.label.padEnd(labelWidth)}  ${formatPairRate(rate.rate).padStart(valueWidth)}  = ${rate.formula}  (${times.join("; ")})`;
+    }),
+  ];
+}
+
+/** The rates as `fx --json` gives them. */
+export function pesoDollarRatesJson(report: PesoDollarRates) {
+  return {
+    spotKind: report.spotKind,
+    impliedRates: report.rates.map((rate) => ({
+      kind: rate.kind, label: rate.label, rate: rate.rate, formula: rate.formula,
+      inputs: rate.inputs.map((input) => ({
+        symbol: input.symbol, price: input.price, currency: input.currency,
+        observedAt: input.observedAt == null ? null : new Date(input.observedAt).toISOString(), sessionOpen: input.open,
+      })),
+    })),
+  };
+}

package/src/cli/quote-answer.ts

@@ -7,7 +7,8 @@ import { canonicalExchange } from "../utils/exchanges";
 import type { CliCommandDef } from "../types/plugin";
 import { currencyCodeNote } from "./currency-hints";
 import { describeSuggestion, suggestListing, suggestUsTicker, type ListingSuggestion } from "./listing-suggestion";
-import { indexRootAlsoLine, indexRootFor, indexRootTryLine } from "./index-roots";
+import { indexRootAlsoLine, indexRootTryLine } from "./index-roots";
+import { indexRootFor } from "../tickers/index-roots";
 import { treasuryYieldLine, treasuryYieldTenor } from "./treasury-yields";
 import { knownGapForTicker } from "./known-gaps";
 import {
@@ -15,10 +16,13 @@ import {
   isNoProviderError,
   listingChoiceNotes,
   listingReadNotes,
+  ListingArgError,
   loadBareVenues,
   notTradedMessage,
+  oneWordCompanyName,
   quoteBareListing,
   requireCliListing,
+  resolveCliListing,
   tradingBoardNote,
   type CliListing,
   type ListingDataRequest,
@@ -105,7 +109,10 @@ export async function answerQuote(
     // BDI asks which exchange (Black Diamond Group) and says nowhere that the Baltic Dry Index is not here.
     listing.exchange ? null : knownGapForTicker(listing.symbol),
   ].filter((line): line is string => !!line);
-  if (!other && tryLines.length === 0) return { result: await withCurrencyPairHint(result, market), listing, notes: [] };
+  if (!other && tryLines.length === 0) {
+    return await answerCompanyName(result, listing, market, request, refresh)
+      ?? { result: await withCurrencyPairHint(result, market), listing, notes: [] };
+  }
   const message = other?.message ?? `${listing.symbol} has no ${request.noun}.`;
   const details = [other?.details, ...tryLines].filter(Boolean).join("\n");
   const oneLine = [
@@ -116,6 +123,34 @@ export async function answerQuote(
   return { result, listing, failure: { message, details, oneLine }, notes: [] };
 }
 
+/**
+ * A company's name typed as one word (`Apple`) that the source says is not a
+ * ticker, answered as the listing search names for it with the line saying so
+ * ("Read "Apple" as AAPL:NASDAQ (Apple Inc.)."), as a name of several words
+ * is. Null when the word names no company, or that listing has no quote
+ * either: the word keeps its own "Not a ticker".
+ */
+async function answerCompanyName(
+  result: QuoteBatchResult,
+  listing: CliListing,
+  market: MarketContext,
+  request: ListingDataRequest,
+  refresh: boolean,
+): Promise<QuoteAnswer | null> {
+  if (!listing.typed || listing.exchange || !notATickerSymbol(errorMessage(result.error) ?? "")) return null;
+  const named = await oneWordCompanyName(listing.typed, market);
+  if (!named) return null;
+  // A listing on a venue the app cannot read is no answer: the word keeps its own "Not a ticker".
+  const resolved = await resolveCliListing(named.key, null, market).catch((error: unknown) => {
+    if (error instanceof ListingArgError) return null;
+    throw error;
+  });
+  if (!resolved) return null;
+  const found = { ...resolved, readAs: named.readAs, ...named.meant ? { meant: named.meant } : {} };
+  const [quoted] = await market.dataProvider.getQuotesBatch([found.request], { forceRefresh: refresh, revalidate: true });
+  return quoted?.quote ? answerQuote(quoted, found, market, request, refresh, null) : null;
+}
+
 /** A listing a command found a quote for, with what `quote` says beside it. */
 interface QuotedListing {
   /** The listing the quote is of: the one typed, or the venue a bare symbol was quoted on. */
@@ -164,7 +199,7 @@ export async function requireQuotedListing(
 
 /**
  * A symbol written like a currency pair that is not a ticker (USD_NGN, as some
- * FX feeds write a pair) names the listing `gloomberb search` finds nearest to
+ * FX feeds write a pair) names the listing `gloom search` finds nearest to
  * it, as `watchlist add` does: "Did you mean USDNGN=X (US Dollar/Nigerian
  * Naira)?". When search finds nothing near, the row keeps its own error and its
  * search hint.