gloomberb 0.16.2 → 0.16.3

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

@@ -20,6 +20,16 @@ import type {
 } from "../../types/plugin";
 import { cliStyles, renderSection, renderStats, renderTable } from "../../utils/cli-output";
 import { humanizeCliKey } from "../result";
+import {
+  exportEntriesTable,
+  exportNumber,
+  exportRowsTable,
+  float32Shortest,
+  reportFooterLines,
+  type CliReportTable,
+  type CliReportTables,
+} from "../report-tables";
+import { labelWithUnit } from "../../utils/display-number";
 import { observationDate } from "../../time-series/price-comparison";
 import type { ResolvedSeries } from "../../time-series/types";
 import type { PaneFunctionReport } from "./report";
@@ -316,20 +326,6 @@ function displayNumber(value: number): string {
   return String(float32Shortest(value) ?? Number(value.toPrecision(12)));
 }
 
-/**
- * Some feeds store prices as float32, so 338.93 arrives as 338.929992676. A value
- * that is exactly a float32 prints as the shortest decimal that rounds back to it,
- * which leaves genuine doubles (never exactly float32 unless short) untouched.
- */
-function float32Shortest(value: number): number | null {
-  if (Math.fround(value) !== value) return null;
-  for (let digits = 1; digits <= 9; digits += 1) {
-    const candidate = Number(value.toPrecision(digits));
-    if (Math.fround(candidate) === value) return candidate;
-  }
-  return null;
-}
-
 function displayTime(time: number): string {
   if (!Number.isFinite(time)) return "-";
   return formatUtcTime(new Date(time));
@@ -337,14 +333,36 @@ function displayTime(time: number): string {
 
 const CALENDAR_RESOLUTIONS = new Set(["1d", "1wk", "1mo"]);
 
-/** Session bars print the trading date the chart and comparison notice use, not the bar's open instant. */
-function seriesPointDate(series: HeadlessSeries, date: HeadlessSeries["points"][number]["date"]): string {
-  const time = date instanceof Date ? date.getTime() : typeof date === "number" ? date : Date.parse(date);
-  if (!Number.isFinite(time)) return typeof date === "string" ? date : "-";
+type SeriesPointDate = HeadlessSeries["points"][number]["date"];
+
+function seriesPointTime(date: SeriesPointDate): number {
+  return date instanceof Date ? date.getTime() : typeof date === "number" ? date : Date.parse(date);
+}
+
+function isDateOnly(date: SeriesPointDate): boolean {
+  return typeof date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(date);
+}
+
+/** Session bars are dated by the trading date the chart and comparison notice use, not the bar's open instant. */
+function calendarSeries(series: HeadlessSeries): (HeadlessSeries & Partial<Pick<ResolvedSeries, "historyResolution" | "timeBasis">>) | null {
   const resolved = series as HeadlessSeries & Partial<Pick<ResolvedSeries, "historyResolution" | "timeBasis">>;
-  return resolved.historyResolution && CALENDAR_RESOLUTIONS.has(resolved.historyResolution)
-    ? observationDate(time, resolved)
-    : formatUtcTime({ time, dateOnly: typeof date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(date) });
+  return resolved.historyResolution && CALENDAR_RESOLUTIONS.has(resolved.historyResolution) ? resolved : null;
+}
+
+function seriesPointDate(series: HeadlessSeries, date: SeriesPointDate): string {
+  const time = seriesPointTime(date);
+  if (!Number.isFinite(time)) return typeof date === "string" ? date : "-";
+  const calendar = calendarSeries(series);
+  return calendar ? observationDate(time, calendar) : formatUtcTime({ time, dateOnly: isDateOnly(date) });
+}
+
+/** The same date for a spreadsheet: the trading date, the calendar date, or the ISO instant. */
+function seriesPointExportDate(series: HeadlessSeries, date: SeriesPointDate): string {
+  const time = seriesPointTime(date);
+  if (!Number.isFinite(time)) return typeof date === "string" ? date : "";
+  const calendar = calendarSeries(series);
+  if (calendar) return observationDate(time, calendar);
+  return isDateOnly(date) ? date as string : new Date(time).toISOString().replace(".000Z", "Z");
 }
 
 function seriesValue(series: HeadlessSeries, value: number | null): string {
@@ -377,6 +395,10 @@ function renderEntries(entries: HeadlessPaneEntry[]): string {
   return renderStats(entries.map((entry) => [entry.label, entry.formatted ?? displayValue(entry.value)]));
 }
 
+function statisticsEntries(stats: NonNullable<HeadlessSeriesResult["stats"]>): HeadlessPaneEntry[] {
+  return Array.isArray(stats) ? stats : Object.entries(stats).map(([label, value]) => ({ label, value }));
+}
+
 function renderBundle(
   definition: HeadlessPaneDefinition,
   result: HeadlessBundleResult,
@@ -412,14 +434,118 @@ function renderSeries(result: HeadlessSeriesResult): string[] {
   ];
   const lines = [renderRows(rows, columns, undefined)];
   if (result.stats) {
-    const entries = Array.isArray(result.stats)
-      ? result.stats
-      : Object.entries(result.stats).map(([label, value]) => ({ label, value }));
-    lines.push("", renderSection("Statistics"), renderEntries(entries));
+    lines.push("", renderSection("Statistics"), renderEntries(statisticsEntries(result.stats)));
   }
   return lines;
 }
 
+/** The headers the text table prints. */
+function displayedColumns(columns: HeadlessPaneColumn[]): HeadlessPaneColumn[] {
+  return columns.map((column) => ({ ...column, header: humanizeCliKey(column.header) }));
+}
+
+const SERIES_FIELDS = ["value", "open", "high", "low", "close", "volume"] as const;
+
+/** Every point of a series: its date (the trading date for session bars) and its values, in the series' unit. */
+function seriesTable(series: HeadlessSeries): CliReportTable {
+  const fields = SERIES_FIELDS.filter((field) => series.points.some((point) => point[field] != null));
+  const unit = series.unit?.trim() ?? "";
+  const dates = series.points.map((point) => seriesPointExportDate(series, point.date));
+  const header = (field: (typeof SERIES_FIELDS)[number]) => {
+    const name = `${field[0]!.toUpperCase()}${field.slice(1)}`;
+    return field === "volume" ? name : labelWithUnit(name, unit);
+  };
+  return {
+    title: series.label,
+    columns: [dates.every((date) => date.length <= 10) ? "Date" : "Time", ...fields.map(header)],
+    rows: series.points.map((point, index) => [
+      dates[index]!,
+      ...fields.map((field) => {
+        const value = point[field];
+        return typeof value === "number" && Number.isFinite(value) ? exportNumber(value) : "";
+      }),
+    ]),
+  };
+}
+
+/** What a report leaves out, for the closing `# incomplete` line. */
+function incompleteDetail(
+  result: HeadlessPaneResult,
+  status: { complete: boolean; unavailableSymbols: string[] },
+): boolean | string {
+  if (status.complete) return false;
+  const requested = result.metadata?.requested;
+  const available = result.metadata?.available;
+  if (typeof requested === "number" && typeof available === "number" && available < requested) {
+    return `${available} of ${requested} available`;
+  }
+  return status.unavailableSymbols.length > 0 ? `no data for ${status.unavailableSymbols.join(", ")}` : true;
+}
+
+function textNotices(result: HeadlessPaneResult): string[] {
+  const notices = result.metadata?.notices;
+  if (!Array.isArray(notices)) return [];
+  return [...new Set(notices.filter((notice): notice is string => typeof notice === "string" && notice.trim().length > 0))];
+}
+
+/**
+ * The tables of a headless report for `--csv` and `--ndjson`, with the text
+ * view's columns: a rows or snapshot report is one table, a bundle one per
+ * section (key/value sections as `Metric,Value`), a series report one per
+ * series with every point, then its statistics. The footer carries the text
+ * view's closing line, notices, notes and errors.
+ */
+export function headlessReportTables(
+  definition: HeadlessPaneDefinition,
+  result: HeadlessPaneResult,
+  args: HeadlessPaneLoadArgs,
+  fallbackTitle: string,
+  freshness: ReportFreshness,
+  status: { complete: boolean; unavailableSymbols: string[] },
+): CliReportTables {
+  const title = reportTitle(definition, args, result, fallbackTitle);
+  let tables: CliReportTable[];
+  switch (definition.shape) {
+    case "rows": {
+      const rowsResult = result as HeadlessPaneResult & { rows: HeadlessPaneRow[]; columns?: HeadlessPaneColumn[] };
+      const columns = displayedColumns(columnsFor(rowsResult.rows, rowsResult.columns, definition.columns));
+      tables = [exportRowsTable(title, columns, rowsResult.rows)];
+      break;
+    }
+    case "bundle":
+      tables = (result as HeadlessBundleResult).sections.map((section) => (
+        "rows" in section && section.rows
+          ? exportRowsTable(section.title, displayedColumns(columnsFor(section.rows, section.columns, definition.columns)), section.rows)
+          : exportEntriesTable(section.title, section.entries)
+      ));
+      break;
+    case "series": {
+      const seriesResult = result as HeadlessSeriesResult;
+      tables = seriesResult.series.map(seriesTable);
+      if (seriesResult.stats) tables.push(exportEntriesTable("Statistics", statisticsEntries(seriesResult.stats)));
+      break;
+    }
+    case "snapshot": {
+      const snapshot = result as HeadlessSnapshotResult;
+      tables = [exportRowsTable(title, displayedColumns(columnsFor(snapshot.items, undefined, definition.columns)), snapshot.items)];
+      break;
+    }
+    default: {
+      const _exhaustive: never = definition.shape;
+      return _exhaustive;
+    }
+  }
+  return {
+    tables,
+    footer: reportFooterLines({
+      freshness,
+      incomplete: incompleteDetail(result, status),
+      errors: result.errors,
+      notes: [...textNotices(result), ...(result.notes ?? [])],
+    }),
+  };
+}
+
 function reportTitle(
   definition: HeadlessPaneDefinition,
   args: HeadlessPaneLoadArgs,
@@ -450,11 +576,8 @@ export function renderHeadlessPaneText(
   freshness: ReportFreshness = deriveHeadlessFreshness(definition, result),
 ): string {
   const lines = [cliStyles.bold(reportTitle(definition, args, result, fallbackTitle)), ""];
-  const notices = result.metadata?.notices;
-  if (Array.isArray(notices)) {
-    const textNotices = [...new Set(notices.filter((notice): notice is string => typeof notice === "string" && notice.trim().length > 0))];
-    if (textNotices.length) lines.push(...textNotices, "");
-  }
+  const notices = textNotices(result);
+  if (notices.length) lines.push(...notices, "");
   switch (definition.shape) {
     case "rows": {
       const rowsResult = result as HeadlessPaneResult & { rows: HeadlessPaneRow[]; columns?: HeadlessPaneColumn[] };
@@ -513,6 +636,7 @@ export async function buildHeadlessFunctionReport(
   const unavailableSymbols = loaded.result.unavailableSymbols ?? (rowCount === 0 ? symbols : []);
   const serialized = serializeHeadlessPaneResult(loaded.definition, loaded.result);
   const freshness = deriveHeadlessFreshness(loaded.definition, loaded.result);
+  const complete = loaded.result.complete !== false && unavailableSymbols.length === 0 && !loaded.result.errors?.length;
   return {
     data: {
       kind: loaded.definition.shape,
@@ -522,7 +646,7 @@ export async function buildHeadlessFunctionReport(
       options: resolved.options,
       rowCount,
       empty: rowCount === 0,
-      complete: loaded.result.complete !== false && unavailableSymbols.length === 0 && !loaded.result.errors?.length,
+      complete,
       unavailableSymbols,
       ...serialized,
       freshness,
@@ -534,5 +658,13 @@ export async function buildHeadlessFunctionReport(
       resolved.label,
       freshness,
     ),
+    tables: headlessReportTables(
+      loaded.definition,
+      loaded.result,
+      loaded.args,
+      resolved.label,
+      freshness,
+      { complete, unavailableSymbols },
+    ),
   };
 }

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

@@ -23,6 +23,7 @@ import {
 import { accessGateStatus, incompleteReportGateMessage } from "./access-gate";
 import { withPersistedCloudSession } from "./cloud-session";
 import { loadForListing } from "../listing-arg";
+import { selectReportTables } from "../report-tables";
 
 async function withPaneRuntime<T>(
   ctx: CliCommandContext,
@@ -33,7 +34,7 @@ async function withPaneRuntime<T>(
     registry: PaneFunctionCatalog;
     resolved: ResolvedPaneFunction;
   }) => Promise<T>,
-  settings: { strictHeadlessOptions?: boolean } = {},
+  settings: { strictHeadlessOptions?: boolean; tableSection?: boolean } = {},
 ): Promise<T> {
   return withMarketData(ctx, async (market) => {
     const context: MarketContext = ctx.cliOptions.refresh ? { ...market, refresh: true } : market;
@@ -59,6 +60,11 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
           + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
         );
       }
+      const tabular = ctx.cliOptions.format === "csv" || ctx.cliOptions.format === "ndjson";
+      if (resolved.tableSection !== undefined && !tabular) {
+        throw new Error("--section picks one table of --csv or --ndjson output.");
+      }
+      if (resolved.tableSection === true) throw new Error("--section needs a section title or number.");
       // A report that fails or comes back empty for an exchange the symbol is not listed on says so.
       const report = await withPersistedCloudSession(
         context,
@@ -82,8 +88,9 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       }
       ctx.printResult({ data: report.data }, {
         text: () => report.text,
+        ...(tabular ? { tables: selectReportTables(report.tables, resolved.tableSection) } : {}),
       });
-    }, { strictHeadlessOptions: true });
+    }, { strictHeadlessOptions: true, tableSection: true });
   });
 }
 

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

@@ -2,8 +2,9 @@ import type { MarketContext } from "../types";
 import type { NormalizedPaneFunctionOptions } from "./capabilities";
 import type { ResolvedPaneFunction } from "./resolver";
 import { buildHeadlessFunctionReport } from "./headless";
-import { appendDomReportFooter, buildDomFunctionReport } from "./dom";
+import { appendDomReportFooter, buildDomFunctionReport, domReportNote } from "./dom";
 import type { ReportFreshness } from "./freshness";
+import type { CliReportTables } from "../report-tables";
 
 export type PaneFunctionReportSource = "headless" | "dom";
 
@@ -29,6 +30,8 @@ interface PaneFunctionReportData {
 export interface PaneFunctionReport {
   data: PaneFunctionReportData;
   text: string;
+  /** What `--csv` and `--ndjson` write: the text view's tables as flat rows, and the closing `#` lines. */
+  tables: CliReportTables;
 }
 
 export function resolvePaneFunctionReportSource(
@@ -61,6 +64,10 @@ export async function buildFunctionReport(
       report.data.truncated === true,
       report.data.freshness,
     );
+    report.tables = {
+      ...report.tables,
+      footer: [...report.tables.footer, `note: ${domReportNote(elapsedMs, report.data.truncated === true)}`],
+    };
   }
   return report;
 }

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

@@ -25,6 +25,7 @@ import {
   type ParsedPaneFunctionArgs,
 } from "./options";
 import {
+  capabilityHasOption,
   capabilityPaneSettings,
   getHeadlessPaneDefinition,
   getPaneFunctionCapability,
@@ -46,6 +47,8 @@ export interface ResolvedPaneFunction {
   optionSettings: Record<string, unknown>;
   capability: PaneFunctionCapability;
   options: NormalizedPaneFunctionOptions;
+  /** `--section` of a report: the table `--csv` and `--ndjson` write, when the function has no `section` option of its own. */
+  tableSection?: string | true;
 }
 
 async function buildPaneInstance(
@@ -126,12 +129,28 @@ export async function applyListingArgument(
   return { ...args, arg: listing.key, options, listing };
 }
 
+/**
+ * `--section` picks one table of a report's `--csv` or `--ndjson` output. A
+ * function that has a `section` option of its own (CALLS: which part of a
+ * transcript) keeps the flag; its report is one table, so there is nothing to
+ * pick there.
+ */
+function takeTableSection(
+  capability: PaneFunctionCapability,
+  options: ParsedPaneFunctionArgs["options"],
+): { options: ParsedPaneFunctionArgs["options"]; tableSection?: string | true } {
+  if (!("section" in options) || capabilityHasOption(capability, "section")) return { options };
+  const { section, ...rest } = options;
+  return { options: rest, tableSection: section };
+}
+
 export async function resolvePaneFunction(
   registry: PaneFunctionCatalog,
   context: MarketContext,
-  args: ParsedPaneFunctionArgs,
-  resolutionSettings: { strictHeadlessOptions?: boolean } = {},
+  parsedArgs: ParsedPaneFunctionArgs,
+  resolutionSettings: { strictHeadlessOptions?: boolean; tableSection?: boolean } = {},
 ): Promise<ResolvedPaneFunction> {
+  let args = parsedArgs;
   if (!args.target) {
     throw new Error("Usage: gloomberb fn <function-or-pane> [argument] [--key value]");
   }
@@ -152,6 +171,12 @@ export async function resolvePaneFunction(
   const createOptions = buildCreateOptions(template, args.arg);
   const headless = getHeadlessPaneDefinition(template, pane);
   const capability = getPaneFunctionCapability(template, pane);
+  let tableSection: string | true | undefined;
+  if (resolutionSettings.tableSection) {
+    const taken = takeTableSection(capability, args.options);
+    args = { ...args, options: taken.options };
+    tableSection = taken.tableSection;
+  }
   const normalizedOptions = normalizeCapabilityOptions(capability, args.options, {
     strict: args.requireBotSafe || (!!headless && resolutionSettings.strictHeadlessOptions === true),
   });
@@ -177,6 +202,7 @@ export async function resolvePaneFunction(
     optionSettings: settings,
     capability,
     options: normalizedOptions,
+    ...(tableSection !== undefined ? { tableSection } : {}),
   };
   resolved.instance = await buildPaneInstance(resolved, context, args.arg);
   return resolved;

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

@@ -74,6 +74,7 @@ import type { ResolvedSeries } from "../../time-series/types";
 import { getQuoteMonitorPaneSettings } from "../../plugins/builtin/ticker-detail/settings";
 import { accessGateSentence } from "./access-gate";
 import { findCollection } from "../../plugins/builtin/portfolio-list/cli/render";
+import { peekCachedBrokerAccounts } from "../../plugins/builtin/portfolio-list/cached-account";
 import {
   paneEvidenceMismatches,
   paneScreenshotEvidenceHook,
@@ -625,6 +626,9 @@ export async function buildDesktopShotPayload(
     deviceScaleFactor,
     watermark,
     tickers,
+    ...(COLLECTION_PANE_IDS.has(resolved.pane.id)
+      ? { brokerAccounts: peekCachedBrokerAccounts(context.config, context.persistence?.resources) }
+      : {}),
     financials,
     ...(instrumentFinancials?.length ? { instrumentFinancials } : {}),
     ...(historyVariants?.length ? { historyVariants } : {}),

package/src/cli/registry.ts

@@ -27,6 +27,8 @@ interface RegisteredCliCommand {
   command: CliCommandDef;
   ownerId: string;
   source: "core" | "plugin";
+  /** Core or a built-in plugin: its declared options are the only ones it takes. External plugins are not held to theirs. */
+  builtin: boolean;
 }
 
 export interface CliCommandRegistry {
@@ -80,6 +82,7 @@ export function buildCliCommandRegistry({
     command: CliCommandDef,
     ownerId: string,
     source: "core" | "plugin",
+    builtin: boolean,
   ) => {
     const tokens = new Set([
       validateCommandToken(command.name, ownerId, source),
@@ -95,7 +98,7 @@ export function buildCliCommandRegistry({
       );
     }
 
-    const entry: RegisteredCliCommand = { command, ownerId, source };
+    const entry: RegisteredCliCommand = { command, ownerId, source, builtin };
     allCommands.push(entry);
     for (const token of tokens) {
       allTokens.set(token, entry);
@@ -103,7 +106,7 @@ export function buildCliCommandRegistry({
   };
 
   for (const command of coreCommands) {
-    registerCommand(command, "core", "core");
+    registerCommand(command, "core", "core", true);
   }
 
   const loadablePlugins: GloomPlugin[] = [];
@@ -117,7 +120,7 @@ export function buildCliCommandRegistry({
     }
     loadablePlugins.push(entry.plugin);
     for (const command of entry.plugin.cliCommands ?? []) {
-      registerCommand(command, entry.plugin.id, "plugin");
+      registerCommand(command, entry.plugin.id, "plugin", entry.source === "builtin");
     }
   }