gloomberb 0.18.2 → 0.18.4

package/src/cli/series-search.ts

@@ -27,7 +27,7 @@ function fredSeriesIdOf(expression: string): string | null {
   return /^FRED:([A-Z0-9]+)$/i.exec(expression)?.[1]?.toUpperCase() ?? null;
 }
 
-/** The FRED series the plugins' catalog charts, as `gloomberb fred` takes them: DFEDTARU, ECBDFR. */
+/** The FRED series the plugins' catalog charts, as `gloom fred` takes them: DFEDTARU, ECBDFR. */
 export function catalogFredSeriesIds(plugins: readonly SeriesSource[]): Set<string> {
   return new Set(plugins.flatMap((plugin) => plugin.series ?? [])
     .flatMap((definition) => definition.expression ? [fredSeriesIdOf(definition.expression)] : [])
@@ -96,14 +96,14 @@ export function renderSeriesMatches(
   const shown = matches.slice(0, limit);
   const count = shown.length < matches.length ? `${shown.length} of ${matches.length}` : String(matches.length);
   const quoted = `"${query.replace(/"/g, "")}"`;
-  // A FRED series named by its id is also one `gloomberb fred` prints.
+  // A FRED series named by its id is also one `gloom fred` prints.
   const asked = query.trim().toUpperCase().replace(/^FRED:/, "");
   const fred = matches.find((match) => match.exact && fredSeriesIdOf(match.expression) === asked);
   const hint = fred
-    ? `Print it with gloomberb fred ${asked}; chart it with gloomberb fn G ${fred.expression}.`
+    ? `Print it with gloom fred ${asked}; chart it with gloom fn G ${fred.expression}.`
     : shown.length < matches.length
-    ? `Chart one with gloomberb fn G <chart>; gloomberb ${rest === "catalog" ? `catalog ${quoted}` : `shot CAT ${quoted}`} lists all ${matches.length}.`
-    : "Chart one with gloomberb fn G <chart>.";
+    ? `Chart one with gloom fn G <chart>; gloom ${rest === "catalog" ? `catalog ${quoted}` : `shot CAT ${quoted}`} lists all ${matches.length}.`
+    : "Chart one with gloom fn G <chart>.";
   return [
     `${renderSection(`Series for "${query}"`)} ${cliStyles.muted(`(${count})`)}`,
     renderTable(

package/src/cli/statement-filings.ts

@@ -1,6 +1,7 @@
 import { apiClient } from "../api-client";
 import type { BankFiguresPayload } from "../api-client/bank-figures";
 import type { FinancialStatement } from "../types/financials";
+import { fetchOfferingFilings, type OfferingFiling } from "../utils/cash-runway";
 import { logFailure } from "../utils/log-failure";
 import { nonUsSecListingVenue } from "../utils/sec";
 
@@ -42,6 +43,8 @@ export interface StatementReportSources {
   /** The company's 10-K, 10-Q, 8-K, 20-F and 40-F filings, newest first. */
   statementFilings(symbol: string): Promise<PeriodicFiling[]>;
   bankFigures(symbol: string): Promise<BankFiguresPayload>;
+  /** The company's latest offering prospectuses (424B5, 424B4), newest first. */
+  offeringFilings?(symbol: string): Promise<OfferingFiling[]>;
 }
 
 export const cloudStatementReportSources: StatementReportSources = {
@@ -62,8 +65,24 @@ export const cloudStatementReportSources: StatementReportSources = {
     });
   },
   bankFigures: (symbol) => apiClient.getCloudBankFigures(symbol),
+  offeringFilings: (symbol) => fetchOfferingFilings(apiClient, symbol),
 };
 
+/**
+ * A US listing's latest offering prospectuses, for the note that its cash
+ * predates one; nothing (and no request) for any other listing, or when
+ * `wanted` is false. A failed read leaves the note out.
+ */
+export async function loadOfferingFilings(
+  sources: StatementReportSources | undefined,
+  listing: { symbol: string; exchange?: string },
+  wanted: boolean,
+): Promise<OfferingFiling[]> {
+  if (!wanted || !sources?.offeringFilings || nonUsSecListingVenue(listing.symbol, listing.exchange)) return [];
+  return sources.offeringFilings(listing.symbol)
+    .catch(logFailure("cli.statement-filings", "Reading the offering filings failed", [] as OfferingFiling[]));
+}
+
 /** The filing a statement row's period was read from: its form when the filing list names it, and its filed date. */
 export interface StatementFiling {
   /** 10-Q, 10-K, 20-F or 40-F; null when the filing is not among those listed. */

package/src/cli/suffixed-listing-rows.ts

@@ -0,0 +1,49 @@
+import { saveConfig } from "../data/config/store";
+import { mergeSavedSuffixedListings } from "../portfolio/suffixed-listings";
+import type { CliCommandContext } from "../types/plugin";
+import { debugLog } from "../utils/debug-log";
+import { logFailure } from "../utils/log-failure";
+import { withConfigData, withMarketData } from "./scoped-context";
+import type { ConfigContext, MarketContext } from "./types";
+
+const log = debugLog.createLogger("cli.suffixed-listings");
+
+/**
+ * The profile with the rows a collection holds under a vendor's suffixed key
+ * (GARAN.IS) merged into their listing's row (`mergeSuffixedListings`), as
+ * the app does at launch, for a command about to change a portfolio or
+ * watchlist: what it reads is then what it saves over. A dry run writes
+ * nothing and reads the profile as it is. A merge that fails leaves the rows
+ * as they were.
+ */
+async function mergedForWrite<TContext extends ConfigContext>(ctx: Pick<CliCommandContext, "cliOptions">, context: TContext): Promise<TContext> {
+  if (ctx.cliOptions.dryRun) return context;
+  try {
+    const merged = await mergeSavedSuffixedListings(await context.store.loadAllTickers(), context.config, {
+      config: saveConfig,
+      tickers: (rows) => context.store.saveTickers(rows),
+    });
+    // In place: a market context's provider reads the config through this object.
+    if (merged) context.config = merged.config;
+    for (const kept of merged?.keptCustom ?? []) log.info("custom fields kept on the suffixed row", kept);
+  } catch (error) {
+    logFailure("cli.suffixed-listings", "Merging suffixed listing rows failed")(error);
+  }
+  return context;
+}
+
+/** `withConfigData` for a command that changes a portfolio or watchlist (`mergedForWrite`). Commands that only read use `withConfigData`. */
+export function withCollectionConfigData<TResult>(
+  ctx: Pick<CliCommandContext, "initConfigData" | "cliOptions">,
+  operation: (context: ConfigContext) => TResult | Promise<TResult>,
+): Promise<TResult> {
+  return withConfigData(async () => mergedForWrite(ctx, await ctx.initConfigData()), operation);
+}
+
+/** `withMarketData` for a command that changes a portfolio or watchlist (`mergedForWrite`). */
+export function withCollectionMarketData<TResult>(
+  ctx: Pick<CliCommandContext, "initMarketData" | "cliOptions">,
+  operation: (context: MarketContext) => TResult | Promise<TResult>,
+): Promise<TResult> {
+  return withMarketData(async () => mergedForWrite(ctx, await ctx.initMarketData()), operation);
+}

package/src/cli/symbol-args.ts

@@ -1,3 +1,6 @@
+import { isFigure, isNumberCell, protectFigureCommas, restoreFigureCommas } from "./symbol-cells";
+import { readTerminalListingCode, unknownBloombergMarket } from "../tickers/terminal-codes";
+
 /** The quote marks a pasted list wraps its entries in: "AAPL", 'MSFT', “NVDA”. */
 const QUOTE_MARKS = "\"'`\u2018\u2019\u201C\u201D";
 const QUOTE_EDGES = new RegExp(`^[${QUOTE_MARKS}]+|[${QUOTE_MARKS}]+$`, "g");
@@ -12,18 +15,37 @@ const LIST_SEPARATOR = /[,;\t\r\n]/;
  * in it is split on those, so an entry may be a company's name (`WHR,
  * Whirlpool Corporation, BRK.B`) or several symbols with spaces between them
  * (`brk.b bf-b` on a pasted line); one without them is split on spaces (`JNK
- * EMB BRK.B`). Which an entry with a space is takes a search: a command that
+ * EMB BRK.B`), or with `phrases` kept whole (`splitSymbolArgLines`). Which an
+ * entry with a space is takes a search: a command that
  * resolves its symbols reads them with `readNameEntries`, and a parser that
- * looks nothing up takes `splitSymbolWords`.
+ * looks nothing up takes `splitSymbolWords`. A comma inside a figure
+ * (`2.582,52`, `1,899.21`) is no separator: the figure stays one entry. One
+ * between plain digits is a decimal comma only on a line with another
+ * separator (`ED 2,5`); alone it splits codes (`9988,5`, `700,388`).
  */
-export function splitSymbolArgs(args: readonly string[]): string[] {
-  return args
-    .flatMap((arg) => {
-      const text = arg.replace(/^\uFEFF/, "");
-      return LIST_SEPARATOR.test(text) ? text.split(LIST_SEPARATOR) : text.split(/\s+/);
-    })
-    .map((entry) => entry.trim().replace(QUOTE_EDGES, "").trim().replace(/\s+/g, " "))
-    .filter(Boolean);
+export function splitSymbolArgs(args: readonly string[], options: { phrases?: boolean } = {}): string[] {
+  return args.flatMap((arg) => splitSymbolArgLines(arg, options).flat());
+}
+
+/**
+ * `splitSymbolArgs` of one argument, its entries kept by the line they are
+ * on, so a figure can be told to sit beside the symbol on its line. With
+ * `phrases`, an argument with spaces and no list separator is one entry, as
+ * an entry between commas is: a company's name (`"Beyond Meat"`) or symbols
+ * typed on one line (`"GME AMC"`), which `readNameEntries` tells apart.
+ */
+export function splitSymbolArgLines(arg: string, { phrases = false }: { phrases?: boolean } = {}): string[][] {
+  const lines = arg.replace(/^\uFEFF/, "").split(/\r\n?|\n/).map((line) => protectFigureCommas(line));
+  const separated = lines.length > 1 || lines.some((line) => LIST_SEPARATOR.test(line));
+  // A terminal's code (`VOD LN`, `JPM US Equity`), or words written as one (`AAPL GP`), is one entry.
+  return lines.map((line) => (separated ? line.split(/[,;\t]/) : phrases || isTerminalCodeLine(line) ? [line] : line.split(/\s+/))
+    .map((entry) => restoreFigureCommas(entry).trim().replace(QUOTE_EDGES, "").trim().replace(/\s+/g, " "))
+    .filter(Boolean));
+}
+
+function isTerminalCodeLine(line: string): boolean {
+  const text = line.trim().replace(QUOTE_EDGES, "").trim();
+  return /\s/.test(text) && (readTerminalListingCode(text) != null || unknownBloombergMarket(text) != null);
 }
 
 /**
@@ -31,15 +53,28 @@ export function splitSymbolArgs(args: readonly string[]): string[] {
  * spaces and no list separator into it: `quote "10 year yield"`, `quote
  * "Apple Inc"` or a pasted line `quote "AAPL MSFT"`. Which of those it is
  * takes a lookup (`readPhraseArgument`); `splitSymbolArgs` would split it
- * into words, each a symbol (10, YEAR, YIELD). Null for anything else:
- * several arguments, one word, or a list with commas.
+ * into words, each a symbol (10, YEAR, YIELD). A figure in it is part of
+ * the phrase (`"10.5 year yield"`, `"fed funds rate 5.25%"`). Null for
+ * anything else: several arguments, one word, a list with commas, or a
+ * pasted row of symbols each followed by its prices (`ED 2.582,52`, `AAPL
+ * 150.00 MSFT 300.00`), which is read as a list is.
  */
 export function quotedPhrase(args: readonly string[]): string | null {
   if (args.length !== 1) return null;
   const text = args[0]!.replace(/^\uFEFF/, "");
-  if (LIST_SEPARATOR.test(text)) return null;
+  if (LIST_SEPARATOR.test(protectFigureCommas(text))) return null;
   const phrase = text.trim().replace(QUOTE_EDGES, "").trim().replace(/\s+/g, " ");
-  return phrase.includes(" ") ? phrase : null;
+  return phrase.includes(" ") && !isPricedRow(phrase.split(" ")) ? phrase : null;
+}
+
+/**
+ * Words that are a sheet's row rather than a phrase: a number (`2.582,52`)
+ * among them, and each word that is no figure followed by one (`ED
+ * 2.582,52`), so no two words of a name or a phrase sit side by side.
+ */
+function isPricedRow(words: readonly string[]): boolean {
+  if (!words.some(isNumberCell) || isFigure(words[0]!)) return false;
+  return words.every((word, index) => isFigure(word) || (index + 1 < words.length && isFigure(words[index + 1]!)));
 }
 
 /**
@@ -50,7 +85,7 @@ export function quotedPhrase(args: readonly string[]): string | null {
  */
 export function splitSymbolWords(args: readonly string[]): string[] {
   return splitSymbolArgs(args)
-    .flatMap((entry) => entry.split(" "))
+    .flatMap((entry) => isTerminalCodeLine(entry) ? [entry] : entry.split(" "))
     .map((word) => word.replace(QUOTE_EDGES, ""))
     .filter(Boolean);
 }

package/src/cli/symbol-cells.ts

@@ -0,0 +1,120 @@
+/**
+ * What one cell of a pasted list or a typed argument is before anything is
+ * looked up: a symbol, a figure (a price, a weight, a share count) or junk
+ * a sheet leaves where a value is missing (`N/A`, `--`, `$$$`). Every list
+ * reader and every lookup of a list's symbols decide it here, so a price
+ * from a European sheet (`2.582,52`) is never searched for as a ticker.
+ */
+
+/** A sign before a figure: plus, hyphen-minus or the minus sign. */
+const SIGN = "[+\\-\u2212]";
+/** The currency marks a sheet writes beside an amount. */
+const CURRENCY = "[$\u20ac\u00a3\u00a5\u20b9\u20a9\u20bd\u20ba\u20aa\u0e3f\u20ab\u00a2]";
+/** Thousands written with an apostrophe (1'234.50) or a no-break or thin space (1 234,50). */
+const GROUP_MARK = "['\u2019\u00a0\u202f\u2009]";
+const FIGURE_BODY = [
+  // 1,899.21 and 1,899: commas between thousands.
+  "\\d{1,3}(?:,\\d{3})+(?:\\.\\d+)?",
+  // 2.582,52, 1.899 and 1.234.567: dots between thousands, a decimal comma.
+  "\\d{1,3}(?:\\.\\d{3})+(?:,\\d+)?",
+  `\\d{1,3}(?:${GROUP_MARK}\\d{3})+(?:[.,]\\d+)?`,
+  // 2,5 and 12,345, and 1234,56: a decimal comma.
+  "\\d{1,3},\\d+",
+  "\\d+,\\d{1,2}",
+  "\\d*\\.\\d+",
+  "\\d+",
+].join("|");
+const FIGURE = new RegExp(
+  `^(?:${SIGN}?${CURRENCY}?${SIGN}?(?:${FIGURE_BODY})(?:%|\u2030|${CURRENCY})?|\\(${CURRENCY}?(?:${FIGURE_BODY})%?\\))$`,
+  "u",
+);
+/** A run of digits and the marks between them, where a comma may be a decimal comma rather than a list's separator. */
+const FIGURE_RUN = new RegExp(`(?<![\\p{L}\\p{N}.])(?:${SIGN}|${CURRENCY})*\\d[\\d.,'\u2019\u00a0\u202f\u2009]*(?:%|\u2030|${CURRENCY})?`, "gu");
+/** Placeholders a sheet writes for a missing value, and its error values: N/A, n.a., #N/A, #VALUE!. */
+const PLACEHOLDER = /^(?:#?n\/a|n\.a\.?|#(?:value!|ref!|div\/0!|name\?|num!|null!|spill!|calc!|getting_data))$/i;
+/** Stands in for a comma inside a figure while a line is split on its separators. */
+const FIGURE_COMMA = "\u0000";
+/** Plain digits split by commas (`7203,10`, `5,700`): a decimal comma, or the line's separator between two codes. */
+const PLAIN_COMMA_RUN = /^\d+(?:,\d+)+$/;
+
+/**
+ * A figure as a sheet or a keyboard writes it, a bare whole number (7203)
+ * included: `2.582,52`, `1,899.21`, `-3.2%`, `€1.234,56`, `(1,234.56)`.
+ */
+export function isFigure(cell: string): boolean {
+  return FIGURE.test(cell.trim());
+}
+
+/**
+ * A figure that is never a symbol: one with a decimal or thousands mark, a
+ * sign, a percent or a currency mark (`1.899`, `2,5`, `+4`, `12%`, `$12`). A
+ * bare whole number is not one, as `7203` and `0700` are tickers on their own.
+ */
+export function isNumberCell(cell: string): boolean {
+  const text = cell.trim();
+  return FIGURE.test(text) && !/^\d+$/.test(text);
+}
+
+/** A cell that names nothing: no letter or digit (`$$$`, `--`, `-`, `…`), or a placeholder for a missing value (`N/A`, `#N/A`). */
+export function isJunkCell(cell: string): boolean {
+  const text = cell.trim();
+  return !/[\p{L}\p{N}]/u.test(text) || PLACEHOLDER.test(text);
+}
+
+/** Why a cell is not a symbol, as a lookup refuses it without asking anything; null for one that may be. */
+function notASymbolReason(cell: string): string | null {
+  if (isJunkCell(cell)) return "not a symbol";
+  if (isNumberCell(cell)) return "a number, not a symbol";
+  return null;
+}
+
+/** An entry of a list that cannot be a symbol, refused before any lookup and never looked up again. */
+export class NotASymbolError extends Error {
+  constructor(readonly input: string, readonly reason: string) {
+    super(`${input.trim()} is ${reason}.`);
+    this.name = "NotASymbolError";
+  }
+}
+
+/** `NotASymbolError` for a cell that is not a symbol, else null. */
+export function notASymbolError(cell: string): NotASymbolError | null {
+  const reason = notASymbolReason(cell);
+  return reason ? new NotASymbolError(cell, reason) : null;
+}
+
+/**
+ * Whether a comma between plain digits on a line is a decimal comma (`ED
+ * 2,5`, `CNX;1899,21`): the line has another separator, a tab, a semicolon or
+ * spaces between its cells. Otherwise the comma is the line's only separator
+ * and splits the digits into cells, as a sheet of codes exports them
+ * (`0700,25`, `7203,10`). Quoted cells and separators at the ends are not
+ * counted.
+ */
+export function hasDecimalCommas(line: string): boolean {
+  const bare = line.replace(/"(?:[^"]|"")*"/g, "\"\"").replace(/^[\s,;]+|[\s,;]+$/g, "");
+  return /[\t;]/.test(bare) || /[^\s,;]\s+[^\s,;]/.test(bare);
+}
+
+/**
+ * The text with each comma inside a figure swapped for a stand-in, so
+ * splitting on commas leaves the figure whole; `restoreFigureCommas` puts
+ * them back. A figure only a number can be (`2.582,52`, `1,899.21`, `2,5%`)
+ * keeps its comma. One of plain digits (`7203,10`) keeps it only where its
+ * comma is a decimal comma: `decimalCommas`, else `hasDecimalCommas` of each
+ * line. A run that is no figure keeps its commas as separators.
+ */
+export function protectFigureCommas(text: string, decimalCommas?: boolean): string {
+  if (decimalCommas == null) {
+    return text.split(/(\r\n?|\n)/).map((part, index) => index % 2 === 1 ? part : protectFigureCommas(part, hasDecimalCommas(part))).join("");
+  }
+  return text.replace(FIGURE_RUN, (run) => {
+    const body = run.replace(/[.,'\u2019]+$/, "");
+    const tail = run.slice(body.length);
+    const figure = body.includes(",") && isFigure(body) && (decimalCommas || !PLAIN_COMMA_RUN.test(body));
+    return figure ? `${body.replaceAll(",", FIGURE_COMMA)}${tail}` : run;
+  });
+}
+
+export function restoreFigureCommas(text: string): string {
+  return text.replaceAll(FIGURE_COMMA, ",");
+}