gloomberb 0.18.3 → 0.18.4

package/src/cli/help.ts

@@ -14,10 +14,10 @@ import {
 /** `--section` of a command whose report has several tables. */
 export const TABLE_SECTION_OPTION = {
   flags: "--section <title|n>",
-  description: "With --csv or --ndjson, write only that table, by its title or number",
+  description: "With --csv or --ndjson, write only that table, by its title, the start of it, or its number",
 };
 
-/** Headings of `gloomberb help`, in display order. */
+/** Headings of `gloom help`, in display order. */
 export const CLI_COMMAND_GROUPS = {
   research: "Research",
   companyData: "Company data",
@@ -37,10 +37,10 @@ const PIPED_HELP_WIDTH = 80;
 
 /** Commands that run as written, for someone who has just installed it. */
 const START_HERE: Array<[string, string]> = [
-  ["gloomberb search apple", "Find a ticker from a company name"],
-  ["gloomberb quote AAPL", "Show the latest price"],
-  ["gloomberb ticker AAPL", "Open the full research report"],
-  ["gloomberb catalog earnings", "Find a function, then run it with fn"],
+  ["gloom search apple", "Find a ticker from a company name"],
+  ["gloom quote AAPL", "Show the latest price"],
+  ["gloom ticker AAPL", "Open the full research report"],
+  ["gloom catalog earnings", "Find a function, then run it with fn"],
 ];
 
 const GLOBAL_OPTIONS: Array<[string, string]> = [
@@ -52,7 +52,8 @@ const GLOBAL_OPTIONS: Array<[string, string]> = [
   ["--refresh", "Fetch fresh data instead of reading the cache"],
   ["--dry-run", "Preview config, cache, notes, alerts, plugin on/off, and remote changes without saving"],
   ["-q, --quiet", "Print no results or errors in text mode, for commands that print results"],
-  ["--color, --no-color", "Force or turn off colors (NO_COLOR=1 also turns them off)"],
+  ["--color, --no-color", "Force or turn off colors (NO_COLOR also turns them off)"],
+  ["--plain, --no-plain", "Plain text for a screen reader or large text: no rule lines, arrows as words, every table column kept with a dash in empty cells. On by default when NO_COLOR is set or output is piped; --no-plain turns it off"],
   ["--width <n>", "Fit tables to n columns (default: the terminal width; piped output is not fitted). shot takes its own --width in pixels"],
 ];
 
@@ -75,8 +76,13 @@ function commandGroup(entry: CliHelpEntry): string {
   return entry.command.help?.group ?? (entry.source === "plugin" ? PLUGIN_COMMANDS_GROUP : OTHER_GROUP);
 }
 
+/**
+ * A usage line as typed. Plugin help written before the rename may start
+ * with the old command name, which prints as `gloom`.
+ */
 function withProgramName(invocation: string): string {
-  return invocation.startsWith("gloomberb ") ? invocation : `gloomberb ${invocation}`;
+  if (invocation.startsWith("gloom ")) return invocation;
+  return `gloom ${invocation.startsWith("gloomberb ") ? invocation.slice("gloomberb ".length) : invocation}`;
 }
 
 function renderInvocation(invocation: string, width: number): string[] {
@@ -112,7 +118,7 @@ export function renderCliHelp(entries: CliHelpEntry[], version: string, descript
   const listed = entries.filter(({ command }) => command.name !== "help");
   const nameWidth = Math.max(0, ...listed.map(({ command }) => visibleLength(command.name)));
   const lines = [
-    `${cliStyles.bold("gloomberb")} ${cliStyles.muted(version)}`,
+    `${cliStyles.bold("gloom")} ${cliStyles.muted(version)}`,
     ...wrapText(description, width),
     "",
     renderSection("Start here"),
@@ -120,10 +126,10 @@ export function renderCliHelp(entries: CliHelpEntry[], version: string, descript
     "",
     renderSection("Usage"),
     ...renderDefinitions([
-      ["gloomberb", "Open the terminal UI"],
-      ["gloomberb <command> [args]", "Run a command and print the result"],
-      ["gloomberb help <command>", "Show a command's usage, options, and examples"],
-      ["gloomberb ticker SAN:EPA", "Name the listing of a symbol that trades in several places (or --exchange EPA)"],
+      ["gloom", "Open the terminal UI"],
+      ["gloom <command> [args]", "Run a command and print the result"],
+      ["gloom help <command>", "Show a command's usage, options, and examples"],
+      ["gloom ticker SAN:EPA", "Name the listing of a symbol that trades in several places (or --exchange EPA)"],
     ], { width }),
   ];
 

package/src/cli/history-export.ts

@@ -0,0 +1,126 @@
+/**
+ * `history --csv` as one fixed table, whatever the symbol, its market's state
+ * or how many symbols were asked for: the prices, the bar's flag and marks,
+ * a coin's or one venue's volume, then the `status` column saying why a row
+ * has no figures and the five fixed columns naming what each row is. A list
+ * of symbols (`history --file`) writes every symbol's bars in one long table,
+ * its rows told apart by `symbol_or_series`, and a symbol that served no bars
+ * as one row with only its status.
+ */
+import type { CliResultColumn } from "./result";
+import type { HistoryRow } from "./history-rows";
+
+/** A bar of one symbol of a list, or the one row of a symbol that served none. */
+export interface HistoryListRow extends HistoryRow {
+  /** The listing the bar is of (`AAPL`, `000660.KS`), as `symbol_or_series` names it. */
+  symbol: string;
+  /** Why the symbol has no bars, as its warning says it; only on a symbol's one row with no bar. */
+  status?: string;
+}
+
+type ExportedRow = Record<string, unknown>;
+
+/** A bar's mark as an export writes it: true or false on a bar, nothing on a symbol's row with no bar. */
+function barMark(key: "partial" | "filled" | "unsettled") {
+  return (row: ExportedRow) => row.date ? row[key] === true : "";
+}
+
+/**
+ * The columns of every `history` export, in this order, in every market
+ * state: a bar still forming (Partial), rebuilt from hourly bars (Filled) or
+ * closing before its settlement (Unsettled) is marked in its own column
+ * whether or not any bar of this run has one, so files of different symbols
+ * or days line up when joined.
+ */
+export const HISTORY_EXPORT_COLUMNS: CliResultColumn<ExportedRow>[] = [
+  { key: "date", header: "Date" },
+  { key: "open", header: "Open" },
+  { key: "high", header: "High" },
+  { key: "low", header: "Low" },
+  { key: "close", header: "Close" },
+  { key: "volume", header: "Volume" },
+  { key: "flag", header: "Flag" },
+  { key: "partial", header: "Partial", value: barMark("partial") },
+  { key: "filled", header: "Filled", value: barMark("filled") },
+  { key: "unsettled", header: "Unsettled", value: barMark("unsettled") },
+  { key: "volumeUnit", header: "Volume unit" },
+  { key: "volumeNote", header: "Volume note" },
+  { key: "venueVolume", header: "Venue volume" },
+  { key: "volumeVenue", header: "Volume venue" },
+];
+
+/** Flags of a break before a bar, whose prices stay; every other code left the prices blank. */
+const BREAK_FLAGS = new Set(["gap", "jump"]);
+
+/**
+ * Why an exported history row has no prices: the symbol's failure, or the
+ * contradiction its source's prices had (`prices left blank: high<open`).
+ * Empty for a bar with its prices.
+ */
+export function historyExportStatus(row: ExportedRow): string {
+  if (typeof row.status === "string" && row.status) return row.status;
+  const blanked = [row.open, row.high, row.low, row.close].every((value) => value == null);
+  const codes = (typeof row.flag === "string" ? row.flag : "").split(",").filter((code) => code && !BREAK_FLAGS.has(code));
+  return row.date && blanked && codes.length > 0 ? `prices left blank: ${codes.join(",")}` : "";
+}
+
+/** The one row a symbol that served no bars exports: its symbol and why, every figure empty. */
+export function historyFailureRow(symbol: string, status: string): HistoryListRow {
+  return {
+    symbol, date: "", open: null, high: null, low: null, close: null, volume: null,
+    currency: null, unit: null, interval: null, flag: null, status,
+  };
+}
+
+/**
+ * A symbol's failure in one line, for its status cell and warning: the
+ * message, and the listings its details offer to choose between, as `quote`
+ * says it (`Choose an exchange for FP. Listings: FP:NEO, FP:TSXV.`).
+ */
+export function oneLineFailure(message: string, details: unknown): string {
+  if (typeof details !== "string") return message;
+  const lines = details.split("\n");
+  const heading = lines.findIndex((line) => /^\S.*:$/.test(line));
+  if (heading < 0) return message;
+  const listings = lines.slice(heading + 1).flatMap((line) => /^\s+([^\s(]+)\s/.exec(line)?.[1] ?? []);
+  return listings.length > 0 ? `${message} ${lines[heading]} ${listings.join(", ")}.` : message;
+}
+
+/** At most this many symbols are named before a shared warning counts the rest. */
+const NAMED_SYMBOLS = 8;
+
+function symbolList(symbols: readonly string[]): string {
+  if (symbols.length <= NAMED_SYMBOLS) return symbols.join(", ");
+  return `${symbols.slice(0, NAMED_SYMBOLS).join(", ")} and ${symbols.length - NAMED_SYMBOLS} more`;
+}
+
+/**
+ * Whether a warning names a symbol as a whole word, in the case symbols are
+ * written in: `F` is named in "Not a ticker: F." but not in "AAPL, FB". A
+ * one-letter symbol is also an article that opens a sentence ("A gap of ..."),
+ * so it counts only where prose would not put one.
+ */
+function namesSymbol(note: string, symbol: string): boolean {
+  const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const after = symbol.length === 1 ? "(?![A-Za-z0-9]|\\s+[a-z])" : "(?![A-Za-z0-9])";
+  return new RegExp(`(?<![A-Za-z0-9])${escaped}${after}`).test(note);
+}
+
+/**
+ * The warnings of a list of symbols, each said once with the symbols it is
+ * about (`AAPL, MSFT: 2026-10-23 is still forming (partial)`), in the order
+ * they first came up. A warning that already names its symbol, as `Not a
+ * ticker: ZZZZQQ.` does, stands alone.
+ */
+export function symbolListNotes(entries: ReadonlyArray<{ symbol: string; notes: readonly string[] }>): string[] {
+  const bySymbol = new Map<string, string[]>();
+  for (const { symbol, notes } of entries) {
+    for (const note of notes) {
+      const symbols = bySymbol.get(note) ?? [];
+      if (!symbols.includes(symbol)) bySymbol.set(note, [...symbols, symbol]);
+    }
+  }
+  return [...bySymbol].map(([note, symbols]) => (
+    symbols.length === 1 && namesSymbol(note, symbols[0]!) ? note : `${symbolList(symbols)}: ${note}`
+  ));
+}

package/src/cli/history-rows.ts

@@ -1,6 +1,6 @@
 import { INDEX_POINTS_EXPORT_UNIT, INDEX_POINTS_LABEL, isIndexLevel } from "../market-data/market/index-level";
 import type { PricePoint } from "../types/financials";
-import { marketPriceFractionDigitCeiling, resolveAssetDisplayKind } from "../market-data/market/format";
+import { formatPriceObservation, marketPriceFractionDigitCeiling, resolveAssetDisplayKind } from "../market-data/market/format";
 import { TIME_RANGES, type TimeRange } from "../time-series/range";
 import { subtractTimeRange } from "../time-series/date-window";
 import {
@@ -28,8 +28,6 @@ const INTRADAY_RESOLUTIONS = ["1m", "5m", "15m", "30m", "45m", "1h"] as const;
 /** A first bar later than this after the range's start is a late start, not a weekend or holiday. */
 const LATE_START_MIN_MS = 10 * DAY_MS;
 const LATE_START_MIN_BARS = 3;
-/** A bar with more than this many calendar periods (`barPeriod`) since the one before follows a gap in the series. */
-const BREAK_GAP_PERIODS = 3;
 /** A close more than this many times the close before it, or less than its hundredth, follows a jump. */
 const BREAK_JUMP_RATIO = 100;
 /** Flag codes for a break before a bar, whose prices stay as served; every other code blanks them. */
@@ -76,6 +74,9 @@ export interface HistoryRow {
   volumeUnit?: string;
   /** Why a coin's bar has no volume: `day in progress`, `rebuilt from hourly bars`, `latest trade` (not a bar), `not reported`. */
   volumeNote?: string;
+  /** A bar without the market's volume: the trades of one venue alone (`volumeVenue`), never its volume. */
+  venueVolume?: number;
+  volumeVenue?: string;
 }
 
 /** A coin's volume: traded value in its quote currency, per UTC day on daily bars. */
@@ -148,8 +149,43 @@ function barPeriod(time: number, interval: ManualChartResolution): number {
 }
 
 /**
- * The breaks before each bar: `gap` after more than three calendar periods
- * with no bar (`barPeriod`), `jump` when its close is over 100 times the last
+ * How many periods (`barPeriod`) in a row without a bar break the series: a
+ * single month in monthly bars, since no market closes for a calendar month
+ * (GF=F's monthly chart went from 2002-08 to 2002-10); three weeks for weekly
+ * and finer bars, which a market's own closures do not reach.
+ */
+function breakGapPeriods(interval: ManualChartResolution): number {
+  return interval === "1mo" ? 1 : 3;
+}
+
+/** A run of periods without a bar: the bars on either side of it, and how many periods it spans. */
+interface HistoryHole {
+  before: number;
+  after: number;
+  periods: number;
+}
+
+/**
+ * The runs of periods without a bar between consecutive bars, oldest first:
+ * every missing month of monthly bars and every missing week of weekly bars,
+ * a closed week included, and for daily and finer bars each break in the
+ * series (breakGapPeriods), since their sessions follow a calendar the bars
+ * do not carry. `times` oldest first.
+ */
+function historyHoles(times: readonly number[], interval: ManualChartResolution): HistoryHole[] {
+  const least = interval === "1mo" || interval === "1wk" ? 1 : breakGapPeriods(interval);
+  const finite = times.filter(Number.isFinite);
+  return finite.slice(1).flatMap((after, index) => {
+    const before = finite[index]!;
+    const periods = barPeriod(after, interval) - barPeriod(before, interval) - 1;
+    return periods >= least ? [{ before, after, periods }] : [];
+  });
+}
+
+/**
+ * The breaks before each bar: `gap` after a month with no bar in monthly
+ * bars, or more than three weeks in finer ones (breakGapPeriods), `jump`
+ * when its close is over 100 times the last
  * close before it, or under a hundredth of it. Closes that are blank, zero or
  * negative are skipped.
  */
@@ -163,7 +199,7 @@ function historyBreakFlags(
   return times.map((time, index) => {
     const flags: string[] = [];
     if (interval && Number.isFinite(time)) {
-      if (previousTime != null && barPeriod(time, interval) - barPeriod(previousTime, interval) > BREAK_GAP_PERIODS) flags.push("gap");
+      if (previousTime != null && barPeriod(time, interval) - barPeriod(previousTime, interval) > breakGapPeriods(interval)) flags.push("gap");
       previousTime = time;
     }
     const close = closes[index];
@@ -218,6 +254,9 @@ export function historyRows(
       ...(point.filled ? { filled: true as const } : {}),
       ...(point.unsettled ? { unsettled: true as const } : {}),
       ...(volume ? { volumeUnit: volume.unit } : {}),
+      ...(values.volume == null && point.venueVolume
+        ? { venueVolume: point.venueVolume.volume, volumeVenue: point.venueVolume.venue }
+        : {}),
       // A coin trades every day, so a bar without volume says why.
       ...(volume && values.volume == null
         ? {
@@ -343,15 +382,28 @@ export function historyReportsVolume(rows: readonly Pick<HistoryRow, "volume">[]
  * are said by their own notes and not counted.
  */
 export function historyMissingVolumeNote(
-  rows: readonly Pick<HistoryRow, "date" | "volume" | "partial" | "filled" | "flag">[],
+  rows: readonly Pick<HistoryRow, "date" | "volume" | "venueVolume" | "partial" | "filled" | "flag">[],
 ): string | null {
   if (!historyReportsVolume(rows)) return null;
   const latestTrade = latestTradeIndex(rows.map((row) => Date.parse(row.date)));
-  const missing = rows.filter((row, index) => row.volume == null && !row.partial && !row.filled
+  const missing = rows.filter((row, index) => row.volume == null && row.venueVolume == null && !row.partial && !row.filled
     && !flagCodes(row).some((code) => !BREAK_FLAGS.has(code)) && index !== latestTrade).length;
   return missingVolumeNotice(missing, rows.length) ?? null;
 }
 
+/**
+ * "9 of 9 bars count IEX trades only, not the market's volume" when bars carry one venue's count in place of the
+ * market's (`venueVolume`), or null.
+ */
+export function historyVenueVolumeNote(rows: readonly Pick<HistoryRow, "venueVolume" | "volumeVenue">[]): string | null {
+  const counted = rows.filter((row) => row.venueVolume != null);
+  if (!counted.length) return null;
+  const venues = [...new Set(counted.map((row) => row.volumeVenue).filter(Boolean))].join(", ") || "one venue";
+  const one = counted.length === 1;
+  return `${counted.length} of ${rows.length} ${one && rows.length === 1 ? "bar" : "bars"} ${one ? "counts" : "count"} ${venues} trades only, `
+    + "not the market's volume";
+}
+
 function neededDecimals(value: number, cap: number): number {
   for (let decimals = 0; decimals < cap; decimals++) {
     if (Number(value.toFixed(decimals)) === value) return decimals;
@@ -383,6 +435,32 @@ export function historyPriceDecimals(rows: readonly Pick<HistoryRow, typeof PRIC
   return largest >= 1 ? Math.max(2, decimals) : decimals;
 }
 
+/** A bar's prices as a table lists them; a bar without a close adds nothing to the decimals. */
+interface BarPrices {
+  open?: number | null;
+  high?: number | null;
+  low?: number | null;
+  close?: number | null;
+}
+
+/**
+ * The decimals one table of bars prints its prices with (`history`, HP's pane
+ * and `fn HP`): historyPriceDecimals over the float32-cleaned prices, so a
+ * feed's 4013.39990234 reads as the 4013.4 it is and the count follows the
+ * asset's display rules (two for gold, three for silver, cents for a US equity).
+ */
+export function barPriceDecimals(bars: readonly BarPrices[], assetCategory?: string): number {
+  const clean = (value: number | null | undefined) => value == null ? null : cleanFloat32Price(value);
+  return historyPriceDecimals(bars.flatMap((bar) => bar.close == null ? [] : [{
+    date: "", open: clean(bar.open), high: clean(bar.high), low: clean(bar.low), close: clean(bar.close)!, volume: null,
+  }]), assetCategory);
+}
+
+/** A price at the table's decimal count (barPriceDecimals), within `maxWidth` when the pane gives one. */
+export function formatBarPrice(value: number, decimals: number, maxWidth?: number): string {
+  return formatPriceObservation(Number(value.toFixed(Math.min(20, decimals))), { minimumFractionDigits: decimals, maxWidth });
+}
+
 /** How far back ALL reaches, in whole years, from the window a history request for it asks for. */
 export function historyAllRangeYears(now = new Date()): number {
   return Math.round((now.getTime() - subtractTimeRange(now, "ALL").getTime()) / (365.25 * DAY_MS));
@@ -459,16 +537,48 @@ export function historyFacts(unit: HistoryUnit, rows: readonly Pick<HistoryRow,
   ].filter(Boolean);
 }
 
+/** Whether a first bar dated `firstDate` lies well after the start of `range`: more than a few bars, weekends and holidays aside. */
+function startsLate(range: TimeRange, interval: ManualChartResolution | null, firstDate: string, now: number): boolean {
+  const first = Date.parse(firstDate);
+  const tolerance = Math.max(LATE_START_MIN_MS, LATE_START_MIN_BARS * CHART_RESOLUTION_STEP_MS[interval ?? RANGE_HISTORY_RESOLUTION[range]]);
+  return Number.isFinite(first) && first - subtractTimeRange(new Date(now), range).getTime() > tolerance;
+}
+
+/**
+ * Where an ALL history starts when that is its source's first bar, well
+ * after the window ALL reaches back to (historyAllRangeYears): BTC-USD's
+ * monthly bars start 2014-09, though it traded from 2010. A monthly bar's
+ * month, otherwise its day. Null for other ranges, and for a history the
+ * window cuts.
+ */
+export function historyAllStart(
+  range: TimeRange,
+  interval: ManualChartResolution | null,
+  firstDate: string | undefined,
+  now = Date.now(),
+): string | null {
+  if (range !== "ALL" || !firstDate || !startsLate(range, interval, firstDate, now)) return null;
+  return interval === "1mo" ? firstDate.slice(0, 7) : firstDate.slice(0, 10);
+}
+
+/** "ALL starts 2014-09; the source has no earlier bar", for the start historyAllStart finds. */
+export function historyAllStartNote(start: string): string {
+  return `ALL starts ${start}; the source has no earlier bar`;
+}
+
 /**
  * What an export should know that its rows do not show: bars coarser than the
- * range is served in, or a first bar well after the start asked for, as for a
- * listing younger than the range. Weekends and holidays are within tolerance.
+ * range is served in, a first bar well after the start asked for, as for a
+ * listing younger than the range, and where an ALL history starts when that
+ * is the source's first bar, unless a coverage line already says where the
+ * source starts (`coverageStated`). Weekends and holidays are within tolerance.
  */
 export function historyNotes(
   range: TimeRange,
   interval: ManualChartResolution | null,
   firstDate: string | undefined,
   now = Date.now(),
+  coverageStated = false,
 ): string[] {
   if (!firstDate) return [];
   const notes: string[] = [];
@@ -477,13 +587,11 @@ export function historyNotes(
     const from = interval === "1mo" ? firstDate.slice(0, 7) : firstDate.slice(0, 10);
     notes.push(`Asked ${range}, got ${BAR_INTERVAL_LABELS[interval]} bars from ${from}`);
   }
-  const first = Date.parse(firstDate);
-  if (range !== "ALL" && Number.isFinite(first)) {
-    const tolerance = Math.max(LATE_START_MIN_MS, LATE_START_MIN_BARS * CHART_RESOLUTION_STEP_MS[interval ?? expected]);
-    if (first - subtractTimeRange(new Date(now), range).getTime() > tolerance) {
-      notes.push(`Asked ${range}, data starts ${firstDate.slice(0, 10)} (first available bar)`);
-    }
+  if (range !== "ALL" && startsLate(range, interval, firstDate, now)) {
+    notes.push(`Asked ${range}, data starts ${firstDate.slice(0, 10)} (first available bar)`);
   }
+  const allStart = coverageStated ? null : historyAllStart(range, interval, firstDate, now);
+  if (allStart) notes.push(historyAllStartNote(allStart));
   return notes;
 }
 
@@ -511,36 +619,80 @@ function utcDay(time: number): string {
   return new Date(time).toISOString().slice(0, 10);
 }
 
-/** The bars flagged `code`, each with the bar before it. */
-function breaksFlagged<Row extends Pick<HistoryRow, "flag">>(rows: readonly Row[], code: string): Array<[Row, Row]> {
-  return rows.flatMap((row, index) => index > 0 && flagCodes(row).includes(code) ? [[rows[index - 1]!, row] as [Row, Row]] : []);
+function monthKey(year: number, month: number): string {
+  return utcDay(Date.UTC(year, month, 1)).slice(0, 7);
+}
+
+/** The first day of week `period` (`barPeriod`): its Monday. */
+function weekStart(period: number): number {
+  return FIRST_MONDAY_MS + period * 7 * DAY_MS;
+}
+
+/** "2026-02", "2026-02 to 2026-03 (2 months)", "the week of 2025-09-29", "2015-06-27 to 2015-08-02 (5 weeks)". */
+function holeText(hole: HistoryHole, interval: ManualChartResolution): string {
+  const { before, after, periods } = hole;
+  if (interval === "1mo") {
+    const period = barPeriod(before, interval) + 1;
+    const first = monthKey(Math.floor(period / 12), period % 12);
+    const last = monthKey(Math.floor((period + periods - 1) / 12), (period + periods - 1) % 12);
+    return periods === 1 ? first : `${first} to ${last} (${periods} months)`;
+  }
+  const length = `${periods} week${periods === 1 ? "" : "s"}`;
+  if (interval === "1wk") {
+    const first = barPeriod(before, interval) + 1;
+    return periods === 1 ? `the week of ${utcDay(weekStart(first))}`
+      : `${utcDay(weekStart(first))} to ${utcDay(weekStart(first + periods) - DAY_MS)} (${length})`;
+  }
+  return `${utcDay(before + DAY_MS)} to ${utcDay(after - DAY_MS)} (${length})`;
+}
+
+/**
+ * "No bar for 2026-02", "No bars for 2001-07, 2002-09 and 2026-02 to 2026-03
+ * (2 months)": every run of periods without a bar (historyHoles), oldest
+ * first, each named. `times` oldest first. Null when there is none.
+ */
+export function historyMissingPeriodsNote(times: readonly number[], interval: ManualChartResolution | null): string | null {
+  const holes = interval ? historyHoles(times, interval) : [];
+  if (!interval || holes.length === 0) return null;
+  const one = holes.length === 1 && holes[0]!.periods === 1 && (interval === "1mo" || interval === "1wk");
+  return `${one ? "No bar" : "No bars"} for ${listItems(holes.map((hole) => holeText(hole, interval)))}`;
+}
+
+/** A bar's date as a history table shows it: the month of a monthly bar, the day of a daily or weekly one, else the UTC time. */
+function holeBarDate(time: number, interval: ManualChartResolution): string {
+  const iso = new Date(time).toISOString();
+  return interval === "1mo" ? iso.slice(0, 7) : isIntradayResolution(interval) ? formatUtcTime(iso) : iso.slice(0, 10);
+}
+
+/**
+ * For each bar, oldest first, whether a run of periods without a bar
+ * (historyHoles) lies between it and the bar before: its change from that
+ * bar spans them. `times` oldest first.
+ */
+export function historyBarsAfterHole(times: readonly number[], interval: ManualChartResolution | null): boolean[] {
+  const after = new Set(interval ? historyHoles(times, interval).map((hole) => hole.after) : []);
+  return times.map((time) => after.has(time));
+}
+
+/**
+ * "CHG marked * spans the missing bars: 2026-04 is from 2026-01": the bar
+ * each change after a run of periods without a bar (historyBarsAfterHole) is
+ * measured from. `times` oldest first. Null when there is none.
+ */
+export function historyChangeBaseNote(times: readonly number[], interval: ManualChartResolution | null): string | null {
+  const holes = interval ? historyHoles(times, interval) : [];
+  if (!interval || holes.length === 0) return null;
+  const bases = holes.map(({ before, after }, index) =>
+    `${holeBarDate(after, interval)}${index === 0 ? " is" : ""} from ${holeBarDate(before, interval)}`);
+  return `CHG marked * spans the missing bars: ${listItems(bases)}`;
 }
 
 /**
- * "No bars for 1980-08 to 1992-11 (148 months)": the periods with no bar
- * before each bar flagged `gap`, the latest few by date and the rest counted.
+ * "No bars for 1980-08 to 1992-11 (148 months)": every run of periods with
+ * no bar between two bars (historyMissingPeriodsNote).
  */
 function historyBreakGapNote(rows: readonly Pick<HistoryRow, "date" | "interval" | "flag">[]): string | null {
-  const interval = rows[0]?.interval;
-  const gaps = interval ? breaksFlagged(rows, "gap") : [];
-  if (!interval || gaps.length === 0) return null;
-  const monthly = interval === "1mo";
-  const spans = gaps.map(([before, after]) => {
-    const [from, to] = [Date.parse(before.date), Date.parse(after.date)];
-    const periods = barPeriod(to, interval) - barPeriod(from, interval) - 1;
-    const length = `${periods} ${monthly ? "month" : "week"}${periods === 1 ? "" : "s"}`;
-    if (monthly) {
-      const month = (time: number, step: number) => {
-        const date = new Date(time);
-        return utcDay(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + step, 1)).slice(0, 7);
-      };
-      return `${month(from, 1)} to ${month(to, -1)} (${length})`;
-    }
-    return `${utcDay(from + (interval === "1wk" ? 7 : 1) * DAY_MS)} to ${utcDay(to - DAY_MS)} (${length})`;
-  });
-  const shown = spans.slice(-LISTED_GAPS);
-  const earlier = spans.length - shown.length;
-  return `No bars for ${listItems([...earlier > 0 ? [`${earlier} earlier ${earlier === 1 ? "gap" : "gaps"}`] : [], ...shown])}`;
+  return historyMissingPeriodsNote(rows.map((row) => Date.parse(row.date)), rows[0]?.interval ?? null);
 }
 
 const closeFormat = new Intl.NumberFormat("en-US", { maximumSignificantDigits: 7, useGrouping: false });
@@ -573,8 +725,9 @@ export function historyJumpNote(rows: readonly Pick<HistoryRow, "date" | "close"
  * "No bar for 2026-10-10": the days a coin, which trades every day, has no
  * daily bar for between its first and last bar. Days before the first bar are
  * before the listing. A market that closes skips weekends and holidays, so its
- * gaps say nothing on their own: for it, and for a coin's other bar sizes, the
- * note names the gaps flagged `gap`, "No bars for 1980-08 to 1992-11 (148 months)".
+ * daily gaps say nothing on their own: for it, and for a coin's other bar
+ * sizes, the note names every month or week without a bar and each break in
+ * daily or finer bars (historyMissingPeriodsNote), "No bar for 2026-02".
  */
 export function historyGapNote(
   rows: readonly Pick<HistoryRow, "date" | "interval" | "flag">[],

package/src/cli/index-roots.ts

@@ -1,44 +1,4 @@
-/**
- * Well-known index roots that people type bare. As a bare symbol each one is
- * another instrument (MOVE is Corvex, MID a fund) or nothing at all (VIX); the
- * index itself is quoted as ^ROOT. Every entry is offered as a command to run,
- * so only roots whose ^ symbol returns a quote belong here.
- */
-const INDEX_ROOTS = new Map([
-  ["VIX", "Cboe Volatility Index"],
-  ["VVIX", "Cboe VIX of VIX Index"],
-  ["VIX9D", "Cboe S&P 500 9-Day Volatility Index"],
-  ["VIX3M", "Cboe S&P 500 3-Month Volatility Index"],
-  ["VXN", "Cboe Nasdaq-100 Volatility Index"],
-  ["OVX", "Cboe Crude Oil ETF Volatility Index"],
-  ["GVZ", "Cboe Gold ETF Volatility Index"],
-  ["SKEW", "Cboe SKEW Index"],
-  ["TNX", "Cboe 10-Year Treasury Yield Index"],
-  ["SPX", "S&P 500 Index"],
-  ["OEX", "S&P 100 Index"],
-  ["MID", "S&P MidCap 400 Index"],
-  ["DJI", "Dow Jones Industrial Average"],
-  ["NDX", "Nasdaq-100 Index"],
-  ["SOX", "PHLX Semiconductor Index"],
-  ["RUT", "Russell 2000 Index"],
-  ["RUI", "Russell 1000 Index"],
-  ["RUA", "Russell 3000 Index"],
-  ["MOVE", "ICE BofA MOVE Index"],
-  ["NYA", "NYSE Composite Index"],
-]);
-
-export interface IndexRoot {
-  /** The index's own symbol: ^VIX. */
-  symbol: string;
-  name: string;
-}
-
-/** The index a bare root names (VIX is ^VIX); null for any other symbol, ^VIX included. */
-export function indexRootFor(symbol: string): IndexRoot | null {
-  const root = symbol.trim().toUpperCase();
-  const name = INDEX_ROOTS.get(root);
-  return name ? { symbol: `^${root}`, name } : null;
-}
+import { indexRootFor, type IndexRoot } from "../tickers/index-roots";
 
 /** A broker's code for an index: VIX.X and $VIX.X as thinkorswim writes it, $VIX as Schwab does. */
 export interface BrokerIndexCode extends IndexRoot {
@@ -66,14 +26,14 @@ export function brokerIndexReadAs(code: BrokerIndexCode): string {
   return `Read ${code.typed} as ${code.symbol} (${code.name}).`;
 }
 
-/** "^VIX  Cboe Volatility Index (try: gloomberb quote ^VIX)", under a bare root that found nothing. */
+/** "^VIX  Cboe Volatility Index (try: gloom quote ^VIX)", under a bare root that found nothing. */
 export function indexRootTryLine(root: IndexRoot, command = "quote"): string {
-  return `${root.symbol}  ${root.name} (try: gloomberb ${command} ${root.symbol})`;
+  return `${root.symbol}  ${root.name} (try: gloom ${command} ${root.symbol})`;
 }
 
-/** "also ^MOVE ICE BofA MOVE Index (gloomberb quote ^MOVE)", under a bare root that quoted another instrument. */
+/** "also ^MOVE ICE BofA MOVE Index (gloom quote ^MOVE)", under a bare root that quoted another instrument. */
 export function indexRootAlsoLine(root: IndexRoot, command = "quote"): string {
-  return `also ${root.symbol} ${root.name} (gloomberb ${command} ${root.symbol})`;
+  return `also ${root.symbol} ${root.name} (gloom ${command} ${root.symbol})`;
 }
 
 /** Cboe's Treasury yield indices: 13-week bill, 5-, 10- and 30-year notes. Each level is a yield in percent. */