gloomberb 0.11.2 → 0.12.0

package/src/plugins/builtin/plugin-module.ts

@@ -2,17 +2,23 @@ import { Fragment, createElement, type ReactNode } from "react";
 import type {
   GloomPlugin,
   GloomPluginContext,
-  PluginCliDescriptor,
 } from "../../types/plugin";
 
-type PluginMetadataKey = "id" | "name" | "version" | "description" | "toggleable" | "order";
+type PluginMetadataKey =
+  | "id"
+  | "name"
+  | "version"
+  | "description"
+  | "toggleable"
+  | "order"
+  | "targets"
+  | "homepage";
 type PluginMetadata = Pick<GloomPlugin, PluginMetadataKey>;
 
 export type PluginModule = Omit<GloomPlugin, PluginMetadataKey>;
 
 const HANDLED_MODULE_KEYS = [
   "cliCommands",
-  "cli",
   "setup",
   "dispose",
   "panes",
@@ -23,11 +29,8 @@ const HANDLED_MODULE_KEYS = [
 ] as const satisfies readonly (keyof PluginModule)[];
 
 type MissingModuleKey = Exclude<keyof PluginModule, typeof HANDLED_MODULE_KEYS[number]>;
-type MissingCliDescriptorKey = Exclude<keyof PluginCliDescriptor, "commands">;
 const ALL_MODULE_KEYS_HANDLED: MissingModuleKey extends never ? true : never = true;
-const ALL_CLI_DESCRIPTOR_KEYS_HANDLED: MissingCliDescriptorKey extends never ? true : never = true;
 void ALL_MODULE_KEYS_HANDLED;
-void ALL_CLI_DESCRIPTOR_KEYS_HANDLED;
 
 interface CompositePluginOptions extends PluginMetadata {
   modules: readonly PluginModule[];
@@ -72,7 +75,6 @@ function composeSlots(modules: readonly PluginModule[]): GloomPlugin["slots"] {
 export function composeBuiltinPlugin(options: CompositePluginOptions): GloomPlugin {
   const { modules, ...metadata } = options;
   const cliCommands = modules.flatMap((module) => module.cliCommands ?? []);
-  const cliDescriptors = modules.flatMap((module) => module.cli?.commands ?? []);
   const panes = modules.flatMap((module) => module.panes ?? []);
   const paneTemplates = modules.flatMap((module) => module.paneTemplates ?? []);
   const capabilities = modules.flatMap((module) => module.capabilities ?? []);
@@ -83,7 +85,6 @@ export function composeBuiltinPlugin(options: CompositePluginOptions): GloomPlug
   return {
     ...metadata,
     ...(cliCommands.length > 0 ? { cliCommands } : {}),
-    ...(cliDescriptors.length > 0 ? { cli: { commands: cliDescriptors } } : {}),
     ...(panes.length > 0 ? { panes } : {}),
     ...(paneTemplates.length > 0 ? { paneTemplates } : {}),
     ...(capabilities.length > 0 ? { capabilities } : {}),

package/src/plugins/builtin/portfolio-list/index.tsx

@@ -48,6 +48,7 @@ export const portfolioListModule: PluginModule = {
       defaultMode: "floating",
       defaultWidth: "40%",
       tickerSource: true,
+      tableExport: true,
       quickSettings: [LIVE_STREAMING_QUICK_SETTING],
       portableShare: {
         private: {

package/src/plugins/builtin/research/index.tsx

@@ -50,6 +50,7 @@ export const researchModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 90, height: 28 },
+      tableExport: true,
     },
     {
       id: "equity-diagnostic",
@@ -68,6 +69,7 @@ export const researchModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 104, height: 24 },
+      tableExport: true,
     },
     {
       id: "relative-valuation",
@@ -77,6 +79,7 @@ export const researchModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 104, height: 24 },
+      tableExport: true,
     },
     {
       id: "earnings-estimates",
@@ -86,6 +89,7 @@ export const researchModule: PluginModule = {
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 104, height: 22 },
+      tableExport: true,
     },
   ],
 

package/src/plugins/builtin/research-search/command-bar-search.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test } from "bun:test";
+import type { CloudSearchHit } from "../../../api-client";
+import { hitResultDef } from "./command-bar-search";
+import { formatHitDateShort } from "./model";
+
+const NOW = new Date("2026-09-01T12:00:00").getTime();
+
+function hit(overrides: Partial<CloudSearchHit>): CloudSearchHit {
+  return {
+    id: "hit-1",
+    docType: "news",
+    sourceId: "doc-1",
+    chunkIndex: 0,
+    ticker: "NVDA",
+    publishedAt: "2026-08-30T09:00:00",
+    title: "Nvidia guides above estimates",
+    url: "https://example.com",
+    snippet: "record <mark>margin</mark> again",
+    score: 1,
+    metadata: { source: "Reuters" },
+    ...overrides,
+  };
+}
+
+describe("formatHitDateShort", () => {
+  /**
+   * Three formats hinge on two boundaries, a day and a year, and the column
+   * is too narrow to tell a mistake from a design choice.
+   */
+  test("switches from age to day to month at the day and year boundaries", () => {
+    const at = (iso: string) => formatHitDateShort(iso, NOW);
+    expect(at("2026-09-01T11:59:30")).toBe("1m");
+    expect(at("2026-09-01T08:45:00")).toBe("3h");
+    expect(at("2026-08-31T12:00:01")).toBe("23h");
+    expect(at("2026-08-31T12:00:00")).toBe("Aug 31");
+    expect(at("2026-01-01T00:00:00")).toBe("Jan 1");
+    expect(at("2025-12-31T23:59:59")).toBe("Dec 2025");
+    // A clock ahead of ours is not "in -2h".
+    expect(at("2026-09-01T14:00:00")).toBe("Sep 1");
+    expect(at("not a date")).toBe("");
+    expect(at(undefined)).toBe("");
+  });
+});
+
+describe("document hit rows", () => {
+  test("put the date on the right and the source and ticker ahead of the snippet", () => {
+    const row = hitResultDef(hit({}), () => {}, NOW);
+    expect(row.badge).toBe("NEWS");
+    expect(row.right).toBe("Aug 30");
+    expect(row.lines).toEqual([{
+      segments: [
+        { text: "Reuters · NVDA · ", emphasis: "muted" },
+        { text: "record ", emphasis: undefined },
+        { text: "margin", emphasis: "match" },
+        { text: " again", emphasis: undefined },
+      ],
+    }]);
+  });
+
+  test("lead with the speaker for a call and the section for a filing, whose form is the badge", () => {
+    const call = hitResultDef(hit({
+      docType: "transcript",
+      metadata: { speaker: "Colette Kress", role: "CFO" },
+    }), () => {}, NOW);
+    expect(call.badge).toBe("CALL");
+    expect(call.lines?.[0]?.segments[0]?.text).toBe("Colette Kress, CFO · NVDA · ");
+
+    const filing = hitResultDef(hit({
+      docType: "filing",
+      metadata: { form: "10-K", section: "Item 1A" },
+    }), () => {}, NOW);
+    expect(filing.badge).toBe("10-K");
+    expect(filing.lines?.[0]?.segments[0]?.text).toBe("Item 1A · NVDA · ");
+
+    const bare = hitResultDef(hit({ metadata: {} }), () => {}, NOW);
+    expect(bare.lines?.[0]?.segments[0]?.text).toBe("NVDA · ");
+
+    // The News section is all one kind, so a badge there would only repeat the heading.
+    expect(hitResultDef(hit({}), () => {}, NOW, { badge: false }).badge).toBeUndefined();
+  });
+});

package/src/plugins/builtin/research-search/command-bar-search.ts

@@ -0,0 +1,175 @@
+import type { CloudSearchDocType, CloudSearchHit } from "../../../api-client";
+import type {
+  CommandBarResultDef,
+  CommandBarSearchProvider,
+  GloomPluginContext,
+} from "../../../types/plugin";
+import { apiClient } from "../../../api-client";
+import { runDocumentSearch } from "./data";
+import { requestDocumentFocus } from "./focus-handoff";
+import {
+  formatHitDate,
+  formatHitDateShort,
+  hitLeadIn,
+  hitTypeLabel,
+  researchSearchInstanceId,
+  RESEARCH_SEARCH_TEMPLATE_ID,
+} from "./model";
+import { parseMarkedSnippet } from "./snippet";
+
+/**
+ * Each hit costs two rows (title, then source and snippet), and the sheet now
+ * takes about half the terminal rather than a fixed sixteen rows. Four apiece
+ * fits both sections without pushing what follows off screen.
+ */
+const COMMAND_BAR_HIT_LIMIT = 4;
+
+const NEWS_DOC_TYPES: CloudSearchDocType[] = ["news"];
+const FILING_DOC_TYPES: CloudSearchDocType[] = ["transcript", "filing"];
+
+export function hitResultDef(
+  hit: CloudSearchHit,
+  openHit: (hit: CloudSearchHit) => void,
+  now = Date.now(),
+  options?: { badge?: boolean },
+): CommandBarResultDef {
+  const leadIn = [hitLeadIn(hit), hit.ticker].filter(Boolean).join(" · ");
+  const snippet = parseMarkedSnippet(hit.snippet).map((segment) => ({
+    text: segment.text,
+    emphasis: segment.marked ? "match" as const : undefined,
+  }));
+  // Source and ticker open the snippet line, so the right column is free for
+  // the date, which is what decides whether a hit is still worth reading.
+  const segments = leadIn
+    ? [{ text: `${leadIn} · `, emphasis: "muted" as const }, ...snippet]
+    : snippet;
+  return {
+    id: hit.id,
+    label: hit.title,
+    detail: [leadIn, formatHitDate(hit.publishedAt)].filter(Boolean).join(" · "),
+    // CALL or the filing form. Dropped in the News section, where every row is
+    // the same kind and a badge would only repeat the heading.
+    badge: options?.badge === false ? undefined : hitTypeLabel(hit),
+    right: formatHitDateShort(hit.publishedAt, now),
+    lines: segments.length > 0 ? [{ segments }] : undefined,
+    keywords: [hit.ticker, hitTypeLabel(hit)],
+    execute: () => openHit(hit),
+  };
+}
+
+interface CorpusSectionOptions {
+  id: string;
+  category: string;
+  priority: number;
+  docTypes: CloudSearchDocType[];
+  badge: boolean;
+  /** Appended below the hits by the section that offers the whole corpus. */
+  searchAllRow?: boolean;
+}
+
+/**
+ * Full-text corpus hits for free text the command bar could not resolve. Every
+ * failure — including the 402 a server-side refusal returns — degrades to no
+ * rows at all: the command bar is not the place to learn that a background
+ * search you never asked for went wrong.
+ *
+ * News is asked for in its own request rather than split out of a shared one: a
+ * single response has to spend its row budget on whichever kind scored better,
+ * so a query matching a hundred wire stories would leave no room for a filing.
+ */
+function createCorpusSearchProvider(
+  ctx: GloomPluginContext,
+  section: CorpusSectionOptions,
+): CommandBarSearchProvider {
+  const openSearchPane = (query: string) => {
+    ctx.createPaneFromTemplate(RESEARCH_SEARCH_TEMPLATE_ID, { arg: query });
+  };
+
+  return {
+    id: section.id,
+    category: section.category,
+    /**
+     * Async sections sit below every synchronous one, ordered by how long they
+     * take to arrive, so a late arrival only ever pushes rows below itself and
+     * never the rows the eye is already on. Instruments answer in ~200ms, the
+     * corpus in ~400ms, Ask AI later still; the view model pins those bands at
+     * 100, 190/200 and 300.
+     */
+    priority: section.priority,
+    minQueryLength: 3,
+    debounceMs: 350,
+
+    async provide(query, _context, signal) {
+      // Only skip when there is no session at all, so a signed-out bar does not
+      // spend a request per query to be told so. Deliberately not gated on the
+      // cached user's plan: that cache is cleared whenever a session refresh
+      // comes back empty, which leaves the app authenticated for every other
+      // surface while reporting itself signed out here. Entitlement is the
+      // server's answer anyway, and it already returns 401 or 402 on its own.
+      if (!apiClient.isSignedIn()) return [];
+
+      let hits: CloudSearchHit[] = [];
+      try {
+        const response = await runDocumentSearch(
+          // One row per story: three matching paragraphs of one article is one
+          // result, and the teaser has three rows to spend.
+          {
+            query,
+            docTypes: section.docTypes,
+            limit: COMMAND_BAR_HIT_LIMIT,
+            count: false,
+            distinct: true,
+          },
+          signal,
+        );
+        hits = response.hits ?? [];
+      } catch {
+        return [];
+      }
+
+      const now = Date.now();
+      const rows = hits.map((hit) => hitResultDef(
+        hit,
+        (target) => {
+          openSearchPane(query);
+          requestDocumentFocus(researchSearchInstanceId(query), target);
+        },
+        now,
+        { badge: section.badge },
+      ));
+      if (!section.searchAllRow || rows.length === 0) return rows;
+      return [
+        ...rows,
+        {
+          id: "search-all",
+          label: "Search all documents →",
+          detail: "Earnings calls, news, and SEC filings",
+          badge: "DOCS",
+          right: "SRCH",
+          execute: () => openSearchPane(query),
+        },
+      ];
+    },
+  };
+}
+
+export function createNewsSearchProvider(ctx: GloomPluginContext): CommandBarSearchProvider {
+  return createCorpusSearchProvider(ctx, {
+    id: "research-search:news",
+    category: "News",
+    priority: 190,
+    docTypes: NEWS_DOC_TYPES,
+    badge: false,
+  });
+}
+
+export function createDocumentSearchProvider(ctx: GloomPluginContext): CommandBarSearchProvider {
+  return createCorpusSearchProvider(ctx, {
+    id: "research-search:documents",
+    category: "Documents",
+    priority: 200,
+    docTypes: FILING_DOC_TYPES,
+    badge: true,
+    searchAllRow: true,
+  });
+}

package/src/plugins/builtin/research-search/data.ts

@@ -0,0 +1,109 @@
+import {
+  apiClient,
+  type CloudSavedSearch,
+  type CloudSavedSearchInput,
+  type CloudSearchDocType,
+  type CloudSearchDocument,
+  type CloudSearchResponse,
+} from "../../../api-client";
+import { ApiRequestError } from "../../../api-client/errors";
+import type { CloudSearchParams } from "../../../api-client/paths";
+import type { PluginPersistence } from "../../../types/plugin";
+
+const DOCUMENT_KIND = "document";
+const CACHE_SOURCE = "research-search";
+const CACHE_SCHEMA_VERSION = 1;
+
+/**
+ * A published transcript, wire story, or filing does not change once indexed,
+ * so re-opening a hit should not hit the network again.
+ */
+const DOCUMENT_CACHE_POLICY = {
+  staleMs: 7 * 24 * 60 * 60 * 1000,
+  expireMs: 90 * 24 * 60 * 60 * 1000,
+} as const;
+
+let persistence: PluginPersistence | null = null;
+
+export function attachResearchSearchPersistence(value: PluginPersistence): void {
+  persistence = value;
+}
+
+export function resetResearchSearchPersistence(): void {
+  persistence = null;
+}
+
+export function statusOf(error: unknown): number | undefined {
+  return error instanceof ApiRequestError ? error.status : undefined;
+}
+
+export function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function isAbortError(error: unknown): boolean {
+  return error instanceof Error && error.name === "AbortError";
+}
+
+export function runDocumentSearch(
+  params: CloudSearchParams,
+  signal?: AbortSignal,
+): Promise<CloudSearchResponse> {
+  return apiClient.searchCloudDocuments(params, { signal });
+}
+
+function documentKey(docType: CloudSearchDocType, sourceId: string): string {
+  return `${docType}:${sourceId}`;
+}
+
+export async function loadSearchDocument(
+  docType: CloudSearchDocType,
+  sourceId: string,
+  signal?: AbortSignal,
+): Promise<CloudSearchDocument> {
+  const key = documentKey(docType, sourceId);
+  const cached = persistence?.getResource<CloudSearchDocument>(DOCUMENT_KIND, key, {
+    sourceKey: CACHE_SOURCE,
+    schemaVersion: CACHE_SCHEMA_VERSION,
+  });
+  if (cached && !cached.stale) return cached.value;
+
+  try {
+    const document = await apiClient.getCloudSearchDocument(docType, sourceId, { signal });
+    persistence?.setResource(DOCUMENT_KIND, key, document, {
+      sourceKey: CACHE_SOURCE,
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      cachePolicy: DOCUMENT_CACHE_POLICY,
+    });
+    return document;
+  } catch (error) {
+    const status = statusOf(error);
+    const expired = persistence?.getResource<CloudSearchDocument>(DOCUMENT_KIND, key, {
+      sourceKey: CACHE_SOURCE,
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      allowExpired: true,
+    });
+    // Losing entitlement has to re-gate the document, not serve it from cache.
+    if (expired && status !== 401 && status !== 402 && status !== 403) return expired.value;
+    throw error;
+  }
+}
+
+export function loadSavedSearches(signal?: AbortSignal): Promise<CloudSavedSearch[]> {
+  return apiClient.getCloudSavedSearches({ signal });
+}
+
+export function createSavedSearch(input: CloudSavedSearchInput): Promise<CloudSavedSearch> {
+  return apiClient.createCloudSavedSearch(input);
+}
+
+export function updateSavedSearch(
+  id: string,
+  update: Partial<CloudSavedSearchInput>,
+): Promise<CloudSavedSearch> {
+  return apiClient.updateCloudSavedSearch(id, update);
+}
+
+export function deleteSavedSearch(id: string): Promise<void> {
+  return apiClient.deleteCloudSavedSearch(id);
+}

package/src/plugins/builtin/research-search/document-view.test.tsx

@@ -0,0 +1,75 @@
+import { afterEach, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import type { CloudSearchDocument, CloudSearchHit } from "../../../api-client";
+import { SearchDocumentView } from "./document-view";
+
+// One unbroken run, so every wrapped line is exactly as wide as the wrap width
+// and the rightmost printed column is the wrap width rather than wherever the
+// last word happened to end.
+const PARAGRAPH = "forward-looking-statement.".repeat(40);
+
+const HIT = {
+  id: "hit-1",
+  docType: "news",
+  sourceId: "doc-1",
+  chunkIndex: 0,
+  ticker: "NVDA",
+  publishedAt: "2026-08-31T12:00:00.000Z",
+  title: "Press Release",
+  url: "https://example.com/doc-1",
+  snippet: "lorem <mark>ipsum</mark> dolor",
+  score: 1,
+  metadata: { source: "Business Wire" },
+} as unknown as CloudSearchHit;
+
+const DOCUMENT = {
+  docType: "news",
+  sourceId: "doc-1",
+  ticker: "NVDA",
+  title: "Press Release",
+  url: "https://example.com/doc-1",
+  publishedAt: "2026-08-31T12:00:00.000Z",
+  chunks: Array.from({ length: 4 }, (_, index) => ({
+    id: `chunk-${index}`,
+    chunkIndex: index,
+    body: PARAGRAPH,
+    metadata: { source: "Business Wire" },
+  })),
+} as unknown as CloudSearchDocument;
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => {
+      testSetup!.renderer.destroy();
+    });
+    testSetup = undefined;
+  }
+});
+
+/**
+ * The wrap width, the scroll box's inset and its scrollbar are three separate
+ * subtractions from the same pane, and counting one of them twice is invisible
+ * in review: the text still renders, just short of the edge.
+ */
+for (const width of [60, 88, 120]) {
+  test(`paragraphs reach the column before the scrollbar at width ${width}`, async () => {
+    testSetup = await testRender(
+      <SearchDocumentView hit={HIT} document={DOCUMENT} loading={false} error={null} width={width} />,
+      { width, height: 20 },
+    );
+    for (let frame = 0; frame < 3; frame += 1) {
+      await act(async () => {
+        await testSetup!.renderOnce();
+      });
+    }
+
+    const rows = testSetup.captureCharFrame().split("\n");
+    // The scrollbar owns the last column on every row it covers, so measure the
+    // text against the column before it.
+    const textRight = Math.max(...rows.map((row) => row.slice(0, width - 1).trimEnd().length));
+    expect(textRight).toBe(width - 1);
+  });
+}