gloomberb 0.18.1 → 0.18.3

package/src/cli/quote-answer.ts

@@ -0,0 +1,179 @@
+import type { QuoteBatchResult } from "../types/data-provider";
+import type { Quote } from "../types/financials";
+import { bareListingNote } from "../tickers/listing-fate";
+import { notATickerSymbol } from "../sources/provider-errors";
+import { looksLikeCurrencyPair } from "../utils/currency-pair";
+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 { treasuryYieldLine, treasuryYieldTenor } from "./treasury-yields";
+import { knownGapForTicker } from "./known-gaps";
+import {
+  futuresTryLine,
+  isNoProviderError,
+  listingChoiceNotes,
+  listingReadNotes,
+  loadBareVenues,
+  notTradedMessage,
+  quoteBareListing,
+  requireCliListing,
+  tradingBoardNote,
+  type CliListing,
+  type ListingDataRequest,
+  type ListingVenue,
+} from "./listing-arg";
+import { withListingSuggestion } from "./not-a-ticker";
+import type { MarketContext } from "./types";
+
+/** The text of an error, or null for none. */
+export function errorMessage(error: unknown): string | null {
+  if (error == null) return null;
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * "APPL is not a US ticker: it is Aptus Pharma Limited on BSE (INR). Did you
+ * mean AAPL (Apple Inc.)?", for a symbol read on a listing abroad that is one
+ * slip from a US ticker, worded as the not-a-ticker answers word it.
+ */
+export function notUsTickerSentence({ target, quote, listing, usSuggestion }: { target: { symbol: string }; quote: Quote | null; listing?: { name: string | null }; usSuggestion?: ListingSuggestion }): string | null {
+  if (!quote || !usSuggestion) return null;
+  const venue = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
+  const name = quote.name || listing?.name;
+  const what = `${name ? `${name} on ` : ""}${venue}${quote.currency ? ` (${quote.currency})` : ""}`;
+  return `${target.symbol} is not a US ticker: it is ${what}. Did you mean ${describeSuggestion(usSuggestion)}?`;
+}
+
+export interface QuoteAnswer {
+  result: QuoteBatchResult;
+  /** The listing the row is: the one asked for, or the venue a bare symbol was quoted on. */
+  listing: CliListing;
+  /** Why there is no quote, when there is more to say than the source's own error. */
+  failure?: { message: string; details?: string; oneLine: string };
+  notes: string[];
+}
+
+/**
+ * One symbol's row of `quote` and `compare`. A listing on an exchange its symbol
+ * is not listed on says so. A bare symbol the data service read on its home
+ * listing abroad names that venue (SXR8 -> XETRA). One no source quotes is
+ * quoted on its listings (`quoteBareListing`), else names them, or asks for an
+ * exchange when several companies list it (2222); a bare index root (VIX) also
+ * names its index (^VIX), and a futures board code a security keeps (GC) its
+ * future (GC=F). Venues are only looked up for a
+ * symbol with no quote, so a request that succeeds costs no search.
+ */
+export async function answerQuote(
+  result: QuoteBatchResult,
+  listing: CliListing,
+  market: MarketContext,
+  request: ListingDataRequest,
+  refresh: boolean,
+  venues: Promise<ListingVenue[]> | null,
+): Promise<QuoteAnswer> {
+  const root = listing.exchange ? null : indexRootFor(listing.symbol);
+  // A bare root that quoted something else, such as MOVE (Corvex), points at the index too.
+  const also = (quote: Quote) => root && quote.instrumentType?.trim().toUpperCase() !== "INDEX"
+    ? [indexRootAlsoLine(root, request.command)] : [];
+  if (result.quote) {
+    // "CAR = Avis Budget Group, NASDAQ (also XETRA, ASX)" names the venue too, so it replaces "SXR8 -> XETRA".
+    const choice = venues ? await listingChoiceNotes(listing, market, result.quote, venues) : listingReadNotes(listing);
+    const venue = choice.length > 0 ? null : bareListingNote(listing, result.quote);
+    // A row saved as 247540:KRX is quoted from KOSDAQ, the board it trades on.
+    const board = tradingBoardNote(listing, result.quote);
+    return { result, listing, notes: [...choice, venue ?? [], board ?? [], also(result.quote), currencyCodeNote(listing, result.quote) ?? []].flat() };
+  }
+  const notTraded = await notTradedMessage(listing, market);
+  if (notTraded) return { result, listing, failure: { message: notTraded, oneLine: notTraded }, notes: [] };
+  if (!isNoProviderError(result.error)) return { result, listing, notes: [] };
+  const other = await quoteBareListing(listing, market, request, { refresh });
+  if (other?.kind === "quoted") {
+    return {
+      result: { target: other.listing.request, quote: other.quote },
+      listing: other.listing,
+      notes: [other.note, ...also(other.quote), currencyCodeNote(listing, other.quote) ?? []].flat(),
+    };
+  }
+  // Other listings already name a futures board code's future (GC=F); with none, it is named here.
+  // A Treasury yield's root (TNX) names its FRED series and the curve beside its index.
+  const yieldTenor = root ? treasuryYieldTenor(listing.symbol) : null;
+  const tryLines = [
+    yieldTenor ? treasuryYieldLine(yieldTenor) : root ? indexRootTryLine(root, request.command) : null,
+    other || listing.exchange ? null : futuresTryLine(listing.symbol, request),
+    // 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: [] };
+  const message = other?.message ?? `${listing.symbol} has no ${request.noun}.`;
+  const details = [other?.details, ...tryLines].filter(Boolean).join("\n");
+  const oneLine = [
+    message,
+    other ? `${other.heading}: ${other.listings.join(", ")}.` : "",
+    ...tryLines,
+  ].filter(Boolean).join(" ");
+  return { result, listing, failure: { message, details, oneLine }, notes: [] };
+}
+
+/** 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. */
+  listing: CliListing;
+  quote: Quote;
+  /** The venue a bare symbol was read on, the currency it may have meant, the US ticker it is one slip from. */
+  notes: string[];
+}
+
+/**
+ * The listing a command that keeps a symbol (`alerts add`) was given, read as
+ * `quote` reads it: the same resolver and the same quote request, so what is
+ * kept is the listing `quote` prints (USDMXN and USD/MXN are USDMXN=X, MXN is
+ * MXN:FWB2) and `quote`'s own notes come back with it. A symbol nothing
+ * quotes fails the command with why, and the nearest listing search finds when
+ * it is near ("Not a ticker: ZZZQQ. Did you mean ZZZQ?"), so nothing is kept
+ * for it.
+ */
+export async function requireQuotedListing(
+  raw: string,
+  exchange: string | null | undefined,
+  market: MarketContext,
+  ctx: Pick<Parameters<CliCommandDef["execute"]>[1], "fail">,
+  command: string,
+): Promise<QuotedListing> {
+  const listing = await requireCliListing(raw, exchange, market, ctx);
+  const venues = loadBareVenues(listing, market);
+  const [result] = await market.dataProvider.getQuotesBatch([listing.request], { revalidate: true });
+  const answer = await answerQuote(result ?? { target: listing.request, quote: null }, listing, market, { command, noun: "quote" }, false, venues);
+  const quote = answer.result.quote;
+  if (!quote) {
+    if (answer.failure) ctx.fail(answer.failure.message, answer.failure.details);
+    const message = errorMessage(answer.result.error) ?? `No quote found for ${listing.key}.`;
+    // The listing search names, else the US ticker it is one slip from (AAPLL for AAPL), which search does not list for a typo.
+    const suggestion = notATickerSymbol(message) && !message.includes(" Did you mean ")
+      ? await suggestListing(listing.symbol, market) ?? await suggestUsTicker(listing.symbol, market)
+      : null;
+    ctx.fail(suggestion ? withListingSuggestion(message, describeSuggestion(suggestion)) : message);
+  }
+  // A bare symbol read on a listing abroad that is one slip from a US ticker says so, as `quote` does.
+  const venue = answer.listing.saved ? null : bareListingNote(answer.listing, quote);
+  const usSuggestion = venue && answer.notes.includes(venue) ? await suggestUsTicker(answer.listing.symbol, market) : null;
+  const notUs = notUsTickerSentence({ target: answer.result.target, quote, listing: { name: quote.name ?? null }, usSuggestion: usSuggestion ?? undefined });
+  return { listing: answer.listing, quote, notes: [...answer.notes, ...notUs ? [notUs] : []] };
+}
+
+/**
+ * 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
+ * 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.
+ */
+async function withCurrencyPairHint(result: QuoteBatchResult, market: MarketContext): Promise<QuoteBatchResult> {
+  const message = errorMessage(result.error);
+  const symbol = message ? notATickerSymbol(message) : null;
+  if (!message || !symbol || !looksLikeCurrencyPair(symbol)) return result;
+  const suggestion = await suggestListing(symbol, market);
+  return suggestion ? { ...result, error: withListingSuggestion(message, describeSuggestion(suggestion)) } : result;
+}
+

package/src/cli/report-tables.ts

@@ -69,7 +69,8 @@ export interface CliReportEntry {
 }
 
 type Cell =
-  | { kind: "blank" }
+  /** `unit`: what the column draws a number of this row in, so a missing figure still names its unit. */
+  | { kind: "blank"; unit?: string }
   | { kind: "text"; text: string; time?: boolean }
   | { kind: "number"; value: number; unit: string }
   /** Text that may read as a number, once the whole column is known. */
@@ -80,6 +81,8 @@ type ResolvedCell = Exclude<Cell, { kind: "textual" }>;
 interface ResolvedColumn {
   header: string;
   cells: ResolvedCell[];
+  /** The unit the column draws its numbers in, for a table with no rows to say it. */
+  unit?: string;
 }
 
 const BLANK = { kind: "blank" } as const;
@@ -265,8 +268,9 @@ function resolveColumn(header: string, cells: Cell[], parseText: boolean): Resol
   };
 }
 
+/** The units a column's numbers are in, a missing figure's own among them, so the header does not change with which figures are missing. */
 function numberUnits(cells: readonly ResolvedCell[]): Set<string> {
-  return new Set(cells.flatMap((cell) => cell.kind === "number" ? [cell.unit] : []));
+  return new Set(cells.flatMap((cell) => cell.kind === "number" ? [cell.unit] : cell.kind === "blank" && cell.unit != null ? [cell.unit] : []));
 }
 
 function cellValue(cell: ResolvedCell): CliReportValue {
@@ -312,8 +316,8 @@ function rowUnits(columns: readonly ResolvedColumn[], mixed: readonly boolean[],
  * metrics whose rows each have one, and otherwise a `<header> unit` column
  * beside a column that mixes them (a rate in % and a spread in bp).
  */
-function assembleTable(title: string, columns: readonly ResolvedColumn[], rowCount: number): CliReportTable {
-  const units = columns.map((column) => numberUnits(column.cells));
+function assembleTable(title: string, columns: readonly ResolvedColumn[], rowCount: number, status?: StatusColumn): CliReportTable {
+  const units = columns.map((column) => rowCount === 0 && column.unit != null ? new Set([column.unit]) : numberUnits(column.cells));
   const mixed = units.map((columnUnits) => columnUnits.size > 1);
   const byRow = mixed.some(Boolean) ? rowUnits(columns, mixed, rowCount) : null;
   const layout = columns.flatMap((column, index) => {
@@ -338,6 +342,7 @@ function assembleTable(title: string, columns: readonly ResolvedColumn[], rowCou
       },
     ];
   });
+  if (status) layout.push({ header: status.header, value: (row: number) => status.values[row] ?? "" });
   return {
     title,
     columns: layout.map((column) => column.header),
@@ -345,28 +350,141 @@ function assembleTable(title: string, columns: readonly ResolvedColumn[], rowCou
   };
 }
 
+/** The `status` column a table of rows ends its own columns with: why a figure is missing, by row. */
+interface StatusColumn {
+  header: string;
+  values: string[];
+}
+
+/**
+ * A number a probe draws through a column's format, to read the unit the
+ * column draws numbers in. A figure format rounds it; a format that prints
+ * it whole passes values through as text and draws no figures of its own.
+ */
+const UNIT_PROBE = 0.1234567891;
+
+/**
+ * A row with nothing in it that a format can still read through: every
+ * field, call and conversion of it is empty. For a format that reads fields of
+ * the row beyond its value and would throw on an empty one.
+ */
+const EMPTY_ROW: unknown = (() => {
+  const empty: unknown = new Proxy(function empty() {}, {
+    get: (_target, key) => key === Symbol.toPrimitive ? (hint: string) => (hint === "number" ? Number.NaN : "") : empty,
+    apply: () => empty,
+  });
+  return empty;
+})();
+
+/**
+ * The unit a column draws a number of this row in (`%` for an IV, `""` for a
+ * plain figure), read from what its format draws for one; null when it draws
+ * no figure for one, passes the value through as it is, or throws.
+ */
+function drawnUnit<Row>(column: CliReportColumn<Row>, row: Row): string | null {
+  const unit = column.unitKey ? (row as Record<string, unknown> | undefined)?.[column.unitKey] : undefined;
+  if (typeof unit === "string" && unit) return unit;
+  if (!column.format) return null;
+  try {
+    const drawn = column.format(UNIT_PROBE, row);
+    if (typeof drawn !== "string" || drawn.trim() === String(UNIT_PROBE)) return null;
+    const read = readDisplay(drawn);
+    return read && read !== BLANK_DISPLAY ? read.unit : null;
+  } catch {
+    // Intentional ignore: a format that cannot draw a number for this row draws no unit for it.
+    return null;
+  }
+}
+
+/**
+ * The unit a column draws its figures in whatever the rows, read without one:
+ * on an empty row, or through a row of nothing when the format throws on an
+ * empty one. The same with rows and without, so a header and the table's
+ * status column do not depend on what was loaded. Null for a column of text.
+ */
+function columnUnit<Row>(column: CliReportColumn<Row>): string | null {
+  if (column.unitKey) return "";
+  if (!column.format) return null;
+  try {
+    column.format(UNIT_PROBE, {} as Row);
+    return drawnUnit(column, {} as Row);
+  } catch {
+    // Intentional ignore: the format reads a field an empty row lacks; read it through a row of nothing.
+    return drawnUnit(column, EMPTY_ROW as Row);
+  }
+}
+
+/** What a status cell says: each reason once, after the columns it is the reason for. */
+function statusText(reasons: ReadonlyArray<{ header: string; text: string }>): string {
+  const byText = new Map<string, string[]>();
+  for (const { header, text } of reasons) byText.set(text, [...byText.get(text) ?? [], header]);
+  return [...byText].map(([text, headers]) => `${headers.join(", ")}: ${text}`).join("; ");
+}
+
+const isMissing = (value: unknown) => value == null || (typeof value === "number" && !Number.isFinite(value));
+
 // Codes a spreadsheet must not turn into numbers, even when they are digits.
 const IDENTIFIER_KEY = /^(?:id|cik|code|cusip|figi|isin|symbol|ticker)$|(?:Id|Cik|Code|Cusip|Figi|Isin|Symbol|Ticker)$/;
 
-/** A table of rows under the columns the text view draws. */
+/**
+ * A table of rows under the columns the text view draws. A figure that is
+ * missing still names the unit its column draws it in, so a header is the same
+ * whichever figures a symbol has. With `status`, a reason the text draws in
+ * place of a missing figure (`not quoted`, `under 7d`) leaves the cell empty
+ * and goes to the `status` column the table ends its own columns with, so a
+ * column of figures holds only numbers. Only a row whose own value is missing,
+ * in a column that draws that row's figures, has a reason: text a format draws
+ * from the rest of the row (a range, N/M, ATM) stays. A table has the column
+ * when one of its columns draws figures through a format, read from the
+ * columns alone so it is there with or without rows, and a table of text has
+ * none; beside a column of its own named Status it is `value_status`.
+ */
 export function exportRowsTable<Row extends Record<string, unknown>>(
   title: string,
   columns: readonly CliReportColumn<Row>[],
   rows: readonly Row[],
+  { status = false }: { status?: boolean } = {},
 ): CliReportTable {
-  return assembleTable(title, columns.map((column) => resolveColumn(
-    column.header,
-    rows.map((row): Cell => {
-      const record = row as Record<string, unknown> | undefined;
-      const value = record?.[column.key];
-      const unit = column.unitKey ? record?.[column.unitKey] : undefined;
-      if (typeof unit === "string" && unit && typeof value === "number" && Number.isFinite(value)) {
-        return { kind: "number", value: exportNumber(value), unit };
-      }
-      return exportCell(value, column.format ? column.format(value, row) : null, column.key);
-    }),
-    !IDENTIFIER_KEY.test(column.key),
-  )), rows.length);
+  const reasons = rows.map((): Array<{ header: string; text: string }> => []);
+  const units = columns.map(columnUnit);
+  // Decided by the columns alone, so a table has the column, or not, whatever rows it has.
+  const withStatus = status && units.some((unit) => unit != null);
+  const resolved = columns.map((column, columnIndex): ResolvedColumn => {
+    const rowUnits = rows.map((row) => drawnUnit(column, row));
+    const values = rows.map((row) => (row as Record<string, unknown> | undefined)?.[column.key]);
+    const { header, cells } = resolveColumn(
+      column.header,
+      rows.map((row, index): Cell => {
+        const value = values[index];
+        const unit = column.unitKey ? (row as Record<string, unknown> | undefined)?.[column.unitKey] : undefined;
+        if (typeof unit === "string" && unit && typeof value === "number" && Number.isFinite(value)) {
+          return { kind: "number", value: exportNumber(value), unit };
+        }
+        return exportCell(value, column.format ? column.format(value, row) : null, column.key);
+      }),
+      !IDENTIFIER_KEY.test(column.key),
+    );
+    const table: ResolvedColumn = {
+      header,
+      cells: cells.map((cell, index): ResolvedCell => {
+        const unit = rowUnits[index];
+        const blank: ResolvedCell = unit != null ? { kind: "blank", unit } : BLANK;
+        if (cell.kind === "blank") return cell.unit == null ? blank : cell;
+        // Text drawn in place of a figure this row does not have, where the column draws this row's figures: a reason.
+        // Text drawn from the rest of the row (a range, N/M, ATM) is no figure's absence and stays.
+        if (!withStatus || cell.kind !== "text" || cell.time || unit == null || !isMissing(values[index])) return cell;
+        reasons[index]!.push({ header: column.header, text: cell.text });
+        return blank;
+      }),
+    };
+    const unit = units[columnIndex];
+    return unit == null ? table : { ...table, unit };
+  });
+  const statusColumn = withStatus ? {
+    header: columns.some((column) => column.header.trim().toLowerCase() === "status") ? "value_status" : "status",
+    values: reasons.map(statusText),
+  } : undefined;
+  return assembleTable(title, resolved, rows.length, statusColumn);
 }
 
 /** Label/value lines as `Metric,Value`; a number's unit moves into its label. */

package/src/cli/result.ts

@@ -46,6 +46,12 @@ export interface CliResult<T = unknown> {
    * `fear-greed` prints its row alone.
    */
   exportFreshness?: ReportFreshness;
+  /**
+   * Why a result that still prints counts as a failure (a report with no
+   * data): the command exits 1, and JSON says `ok: false` with this as
+   * `error` beside the data, so the envelope and the exit status agree.
+   */
+  failure?: CliErrorObject;
 }
 
 export interface CliErrorObject {
@@ -110,8 +116,9 @@ export interface CliResultRenderOptions<T = unknown, Row = Record<string, unknow
   exportNotes?: readonly string[];
 }
 
-interface CliResultJsonEnvelope<T> extends Omit<CliResult<T>, "freshness" | "exportFreshness"> {
-  ok: true;
+interface CliResultJsonEnvelope<T> extends Omit<CliResult<T>, "freshness" | "exportFreshness" | "failure"> {
+  ok: boolean;
+  error?: CliErrorObject;
   /** Where the data comes from, as CSV's closing `#` lines say it. */
   source?: ExportSource;
   columns?: Array<Pick<CliResultColumn, "key" | "header" | "align" | "width">>;
@@ -398,14 +405,15 @@ export function serializeCliResult<T, Row extends Record<string, unknown> = Reco
   options: CliGlobalOptions,
   renderOptions: CliResultRenderOptions<T, Row> = {},
 ): string {
-  const { freshness, exportFreshness, ...rest } = result;
+  const { freshness, exportFreshness, failure, ...rest } = result;
   const cited = freshness ?? exportFreshness;
   if (options.format === "json") {
     const columns = serializeColumns(renderOptions.columns);
     const window = Array.isArray(result.data) ? windowed(result.data as unknown[], options, renderOptions) : null;
     const cut = window ? cutMetadata(window) : null;
     const envelope: CliResultJsonEnvelope<T> = {
-      ok: true,
+      ok: !failure,
+      ...(failure ? { error: failure } : {}),
       ...rest,
       ...(freshness || cut ? { metadata: { ...rest.metadata, ...(freshness ? { freshness } : {}), ...(cut ? { rows: cut } : {}) } } : {}),
       data: window ? window.rows as T : result.data,

package/src/cli/series-search.ts

@@ -1,6 +1,7 @@
 import { seriesExpression } from "../series/registry";
 import type { SeriesDefinition } from "../series/types";
 import { cliStyles, renderSection, renderTable, wrapText } from "../utils/cli-output";
+import { currencyCodeLabel } from "../utils/currency-units";
 
 /** A data catalog series a query names, as the CLI lists it. */
 export interface SeriesMatch {
@@ -108,7 +109,7 @@ export function renderSeriesMatches(
     renderTable(
       [{ header: "Series" }, { header: "Unit" }, { header: "Frequency", optional: true }, { header: "Publisher", optional: true },
         { header: "Chart", shrink: false }],
-      shown.map((match) => [match.name, match.unit, match.frequency, match.publisher ?? "", cliStyles.command(shellArgument(match.expression))]),
+      shown.map((match) => [match.name, currencyCodeLabel(match.unit), match.frequency, match.publisher ?? "", cliStyles.command(shellArgument(match.expression))]),
     ),
     "",
     ...wrapText(hint, width).map((line) => cliStyles.muted(line)),

package/src/cli/symbol-list.ts

@@ -4,6 +4,8 @@ import { splitSymbolArgs, splitSymbolWords, stripStrayEdges, uniqueSymbols } fro
 
 /** Header cells that name a spreadsheet's symbol column, compared without case, spaces or punctuation. */
 const SYMBOL_HEADERS = new Set(["symbol", "symbols", "ticker", "tickers", "code", "stockcode", "securitycode", "instrument"]);
+/** A header naming a column of company names, read when no column names the symbols. */
+const NAME_HEADERS = new Set(["name", "names", "company", "companies", "companyname", "security", "securityname", "issuer", "issuername"]);
 
 /** One symbol as it can be typed: AAPL, $nvda, TTF.AS, SAN:EPA, BRK-B, 7203.T, ^GSPC, ES=F. */
 const SYMBOL_TOKEN = /^\$?[\p{L}\p{N}^][\p{L}\p{N}.:\-^=/&]{0,23}$/u;
@@ -82,17 +84,32 @@ interface SymbolText {
   symbols: string[];
   /** Cells beside the symbol column of a table with no header, in reading order; empty for a list or a CSV with a header. */
   ignored: string[];
+  /**
+   * The symbols are a list's entries, each a line or a cell of a list split
+   * by semicolons or commas, and are read as typed entries are
+   * (`readNameEntries`): one with spaces is a company's name (`Altria
+   * Group`), or symbols written on one line (`AAPL MSFT`).
+   */
+  entries?: true;
 }
 
 /**
  * The symbols in a file or piped text, in order. A spreadsheet export reads
- * from the column its header names (Symbol, Ticker, Code). Without a header,
+ * from the column its header names (Symbol, Ticker, Code), else from its
+ * Name or Company column, as `entries`. Without a header,
  * every cell is a symbol unless some column after the first holds a name, a
  * price or a weight: that table is read by its first column, and the cells
  * beside it are returned as `ignored` so the command can name them. A list
  * split by commas, spaces or newlines gives every entry, even when a line of
- * it is ragged or carries a stray separator (`"BIMAS ,"`). A byte order mark,
- * Windows line ends, blank lines and lines starting with # or // are ignored.
+ * it is ragged or carries a stray separator (`"BIMAS ,"`). A list of lines
+ * gives each line whole, and a list of names split by semicolons or commas
+ * (one line, or one name a line) each cell, as `entries`: a line with spaces
+ * is a company's name (`Altria Group`) or symbols on one line, which reading
+ * the entries tells apart. Names beside other text (`Apple Inc,Technology`)
+ * are a table read by its first column, its names as `entries`. A list split
+ * by spaces with figures beside the symbols (`AAPL 150.00`) is a table. A
+ * byte order mark, Windows line ends, blank lines and lines starting with #
+ * or // are ignored.
  */
 export function parseSymbolText(text: string): SymbolText {
   const normalized = text.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
@@ -105,13 +122,27 @@ export function parseSymbolText(text: string): SymbolText {
   const exact = header.findIndex((cell) => SYMBOL_HEADERS.has(cell));
   const column = exact >= 0 ? exact : header.findIndex((cell) => cell.includes("symbol") || cell.includes("ticker"));
   if (column >= 0) return { symbols: records.slice(1).map((cells) => cells[column] ?? "").filter(Boolean), ignored: [] };
+  // Without one, a delimited export's Name or Company column holds the companies, read as typed names are.
+  const nameColumn = delimiter ? header.findIndex((cell) => NAME_HEADERS.has(cell)) : -1;
+  if (nameColumn >= 0) return { symbols: records.slice(1).map((cells) => cells[nameColumn] ?? "").filter(Boolean), ignored: [], entries: true };
   // A separator or quote mark stuck to a cell is dropped (and named) when it is read, so it does not make the list a table.
   const cleaned = records.map((cells) => cells.map((cell) => stripStrayEdges(cell).text));
+  const figures = cleaned.some((cells) => cells.some((cell, index) => index > 0 && NUMBER_CELL.test(cell) && /\d/.test(cell)));
+  // Lines split by spaces alone are entries, unless figures sit beside the symbols.
+  if (!delimiter && !figures) return { symbols: records.map((cells) => cells.join(" ")), ignored: [], entries: true };
   const grid = cleaned.every((cells) => cells.every((cell, index) => !cell || (looksLikeSymbol(cell) && (index === 0 || !NUMBER_CELL.test(cell)))));
   if (grid) return { symbols: records.flat().filter(Boolean), ignored: [] };
+  // Names split by semicolons or commas, with no figures: one pasted line, or one name a line with a separator left
+  // on it, is a list. A name beside a sector or any other text is a table, read by its first column below.
+  const names = cleaned.some((cells) => /\s/.test(cells[0] ?? ""));
+  if (!figures && (records.length === 1 || (names && cleaned.every((cells) => cells.filter(Boolean).length <= 1)))) {
+    return { symbols: records.flat().filter(Boolean), ignored: [], entries: true };
+  }
   return {
     symbols: records.map((cells) => cells[0] ?? "").filter(Boolean),
     ignored: records.flatMap((cells) => cells.slice(1)).filter(Boolean),
+    // A first column of names (Apple Inc) is read as typed names are.
+    ...names ? { entries: true as const } : {},
   };
 }
 
@@ -151,8 +182,10 @@ export interface SymbolListSource {
   stdinPiped?: boolean;
   /**
    * Reads the typed entries (`splitSymbolArgs`) as symbols, such as
-   * `readNameEntries`, which keeps a company's name whole. Without it every
-   * entry is its words, each a symbol.
+   * `readNameEntries`, which keeps a company's name whole, and then the
+   * entries of each list a file or standard input holds. Called first for
+   * what was typed, even when that is nothing. Without it every entry is its
+   * words, each a symbol.
    */
   readEntries?: (entries: string[]) => Promise<string[]>;
 }
@@ -176,17 +209,20 @@ export async function readSymbolList(source: SymbolListSource): Promise<{ symbol
   const readStdin = source.readStdin ?? (() => Bun.stdin.text());
   const wantsStdin = source.args.includes("-") || source.file === "-";
   const typedArgs = source.args.filter((arg) => arg !== "-");
+  const readEntries = (entries: string[]) => source.readEntries ? source.readEntries(entries) : Promise.resolve(splitSymbolWords(entries));
   const typed = source.readEntries ? await source.readEntries(splitSymbolArgs(typedArgs)) : splitSymbolWords(typedArgs);
   const collected = [...typed];
   // A separator left on the end of what was typed: `UPST;`, or a list that ends in a comma.
   const strays = new Set<string>(stripStrayEdges(typedArgs.join(" ")).notes);
   const ignored: string[] = [];
-  const addCells = ({ symbols, ignored: beside }: SymbolText) => {
-    for (const cell of symbols) {
+  const addCells = async ({ symbols, ignored: beside, entries }: SymbolText) => {
+    const cells = symbols.map((cell) => {
       const cleaned = stripStrayEdges(cell);
       cleaned.notes.forEach((note) => strays.add(note));
-      collected.push(cleaned.text);
-    }
+      return cleaned.text;
+    }).filter(Boolean);
+    // A list's lines and names are read as typed entries are: `Altria Group` stays one company.
+    collected.push(...entries ? await readEntries(cells) : cells);
     ignored.push(...beside);
   };
   if (source.file != null && source.file !== "-") {
@@ -198,10 +234,10 @@ export async function readSymbolList(source: SymbolListSource): Promise<{ symbol
       const code = (error as NodeJS.ErrnoException).code;
       throw new SymbolListError(code === "ENOENT" ? `No file at ${source.file}.` : `Could not read ${source.file}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    addCells(parseSymbolText(text));
+    await addCells(parseSymbolText(text));
   }
   if (wantsStdin || (typed.length === 0 && source.file == null && (source.stdinPiped ?? stdinIsPiped()))) {
-    addCells(parseSymbolText(await readStdin()));
+    await addCells(parseSymbolText(await readStdin()));
   }
   const ignoredNote = ignoredCellsNote(ignored);
   return { ...uniqueSymbols(collected), notes: [...strays, ...ignoredNote ? [ignoredNote] : []] };

package/src/cli/types.ts

@@ -5,6 +5,7 @@ import { AssetDataRouter } from "../sources/provider-router";
 import type { AppServices } from "../core/app-services";
 import type { CapabilityInvoker } from "../capabilities/types";
 import type { StatementReportSources } from "./statement-filings";
+import type { FxHistoryClient } from "../market-data/fx-closes";
 
 export type ConfigContext = {
   config: AppConfig;
@@ -15,12 +16,15 @@ export type ConfigContext = {
 
 export type MarketContext = ConfigContext & {
   dataProvider: AssetDataRouter;
+  resolveBroker?: (brokerType: string) => import("../types/broker").BrokerAdapter | null;
   /** Charts catalog series in a report run without the plugin runtime. */
   seriesCapabilities?: CapabilityInvoker;
   /** `--refresh`: prefetched data bypasses the local cache. */
   refresh?: boolean;
   /** Filings behind the statements and a bank's figures, read from Gloom Cloud; absent where the data service is a stand-in. */
   statementSources?: StatementReportSources;
+  /** Daily FX closes (`fx --date`, converted INS values); Gloom Cloud unless a test stands in for it. */
+  fxHistory?: FxHistoryClient;
 };
 
 export type CliServicesContext = {