gloomberb 0.10.3 → 0.10.4

package/src/components/chart/static/chart/axis-overlays.tsx

@@ -31,6 +31,12 @@ function alignAxisLabel(label: string, width: number, index: number, count: numb
   return `${" ".repeat(left)}${clipped}${" ".repeat(padding - left)}`;
 }
 
+export interface StaticXAxisMarker {
+  ratio: number;
+  label: string;
+  color: string;
+}
+
 export function StaticXAxisLabels({
   labels,
   positionedLabels,
@@ -41,6 +47,7 @@ export function StaticXAxisLabels({
   cursorLabel,
   cursorColor,
   cursorBackgroundColor,
+  extraMarkers,
 }: {
   labels: string[];
   positionedLabels?: readonly StaticChartXAxisLabel[];
@@ -51,6 +58,8 @@ export function StaticXAxisLabels({
   cursorLabel?: string | null;
   cursorColor?: string;
   cursorBackgroundColor?: string;
+  /** Anchors that stay put while the cursor moves, such as a measure start. */
+  extraMarkers?: readonly StaticXAxisMarker[];
 }) {
   const uiHost = useUiHost();
   const { cellWidthPx = 8, fractionalViewport = false } = useUiCapabilities();
@@ -95,6 +104,10 @@ export function StaticXAxisLabels({
       flexDirection="row"
       position="relative"
       overflow="hidden"
+      data-gloom-role="chart-time-axis"
+      data-gloom-label={(visiblePositionedLabels.length > 0
+        ? visiblePositionedLabels.map((entry) => entry.label)
+        : visibleLabels).join(" ")}
     >
       {uiHost.kind === "desktop-web" && visiblePositionedLabels.length > 0 ? (
         <Box position="absolute" left={0} top={0} width={width} height={1}>
@@ -139,6 +152,39 @@ export function StaticXAxisLabels({
           })}
         </Box>
       )}
+      {extraMarkers?.map((marker) => {
+        const label = marker.label.slice(0, width);
+        const ratio = clampRatio(marker.ratio);
+        if (label.length === 0) return null;
+        return (
+          <Text
+            key={`${marker.label}:${marker.ratio}`}
+            fg={marker.color}
+            bg={cursorBackgroundColor}
+            selectable={false}
+            style={fractionalViewport
+              ? {
+                position: "absolute",
+                left: `${ratio * 100}%`,
+                top: 0,
+                transform: "translateX(-50%)",
+                whiteSpace: "pre",
+                pointerEvents: "none",
+                zIndex: 2,
+              }
+              : {
+                position: "absolute",
+                left: Math.max(0, Math.min(width - label.length, Math.round(ratio * (width - 1)) - Math.floor(label.length / 2))),
+                top: 0,
+                whiteSpace: "pre",
+                pointerEvents: "none",
+                zIndex: 2,
+              }}
+          >
+            {label}
+          </Text>
+        );
+      })}
       {clippedCursorLabel && (cursorLeftPercent !== null || cursorLeft !== null) ? (
         <Text
           fg={cursorColor}

package/src/components/command-bar/action-runtime.ts

@@ -238,6 +238,7 @@ export function useCommandBarActionRuntime({
     adaptTickerSearchRouteResult,
     createPaneTemplateItem,
     getAvailablePaneShortcutTemplates,
+    getAvailablePaneTemplates,
     nonShortcutPaneTemplateItems,
     openPaneTemplateWorkflow,
     paneShortcutItems,
@@ -295,6 +296,7 @@ export function useCommandBarActionRuntime({
     createPluginCommandItem,
     executeCollectionCommand,
     getAvailablePaneShortcutTemplates,
+    getAvailablePaneTemplates,
     getAvailablePluginCommands,
     getWorkflowFieldStringValue,
     getWorkflowInputRef,
@@ -307,6 +309,7 @@ export function useCommandBarActionRuntime({
     openInlineConfirm,
     openModeRoute,
     openPaneTemplateWorkflow,
+    openPluginCommandWorkflow,
     openWorkflowFieldPicker,
     paneShortcutItems,
     persistLayoutChange,

package/src/components/command-bar/assist/inventory.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, test } from "bun:test";
+import type { CommandDef, PaneTemplateDef } from "../../../types/plugin";
+import type { Command } from "../commands/registry";
+import { buildAssistCommandInventory } from "./inventory";
+
+function command(overrides: Partial<Command> & { prefix: string }): Command {
+  return {
+    id: overrides.prefix.toLowerCase(),
+    label: "Command",
+    description: "A command",
+    category: "Config",
+    ...overrides,
+  };
+}
+
+function paneTemplate(overrides: Partial<PaneTemplateDef> & { id: string }): PaneTemplateDef {
+  return {
+    paneId: "pane",
+    label: "Template",
+    description: "A template",
+    ...overrides,
+  };
+}
+
+describe("buildAssistCommandInventory", () => {
+  test("maps arg placeholders onto the kinds the shortcut parser uses", () => {
+    const inventory = buildAssistCommandInventory({
+      commands: [
+        command({ prefix: "DES", aliases: ["T"], label: "Description", hasArg: true, argPlaceholder: "ticker" }),
+        command({ prefix: "HELP", label: "Help", description: "Open the help window" }),
+        command({ prefix: "LAY", label: "Layout Actions", hasArg: true, argPlaceholder: "action" }),
+      ],
+      pluginCommands: [{
+        id: "direct-message",
+        label: "DM",
+        description: "Open a DM",
+        keywords: [],
+        category: "navigation",
+        shortcut: "dm",
+        shortcutArg: { placeholder: "@username" },
+        execute: () => {},
+      }],
+      paneTemplates: [
+        paneTemplate({
+          id: "research",
+          label: "New Research Pane",
+          description: "Research view",
+          shortcut: { prefix: "RV", argPlaceholder: "tickers", argKind: "ticker-list" },
+        }),
+        paneTemplate({ id: "econ", label: "Econ", shortcut: { prefix: "ECON" } }),
+      ],
+    });
+
+    expect(inventory).toEqual([
+      { prefix: "DES", name: "Description", description: "A command", arg: { kind: "ticker", placeholder: "ticker" } },
+      { prefix: "HELP", name: "Help", description: "Open the help window" },
+      { prefix: "LAY", name: "Layout Actions", description: "A command", arg: { kind: "text", placeholder: "action" } },
+      { prefix: "DM", name: "DM", description: "Open a DM", arg: { kind: "text", placeholder: "@username" } },
+      { prefix: "RV", name: "Research", description: "Research view", arg: { kind: "ticker-list", placeholder: "tickers" } },
+      { prefix: "ECON", name: "Econ", description: "A template" },
+    ]);
+  });
+
+  test("drops prefixless commands and keeps the entry the bar would run for a duplicate prefix", () => {
+    const inventory = buildAssistCommandInventory({
+      commands: [
+        command({ prefix: "", label: "New Portfolio" }),
+        command({ prefix: "  ", label: "Reset All Data" }),
+        command({ prefix: "PL", label: "Manage Plugins" }),
+      ],
+      pluginCommands: [],
+      paneTemplates: [
+        paneTemplate({ id: "plugins-pane", label: "Plugin List", shortcut: { prefix: "pl" } }),
+      ],
+    });
+
+    expect(inventory).toEqual([
+      { prefix: "PL", name: "Manage Plugins", description: "A command" },
+    ]);
+  });
+
+  test("caps the inventory at the server limit", () => {
+    const inventory = buildAssistCommandInventory({
+      commands: Array.from({ length: 40 }, (_, index) => command({ prefix: `C${index}` })),
+      pluginCommands: [],
+      paneTemplates: [],
+      limit: 25,
+    });
+
+    expect(inventory).toHaveLength(25);
+    expect(inventory.at(-1)?.prefix).toBe("C24");
+  });
+});

package/src/components/command-bar/assist/inventory.ts

@@ -0,0 +1,92 @@
+import type { AssistCommandDescriptor } from "../../../api-client";
+import type { CommandDef, PaneTemplateDef } from "../../../types/plugin";
+import type { Command } from "../commands/registry";
+import { getPaneTemplateDisplayLabel } from "../pane-templates/items";
+import {
+  getCommandShortcutArgKind,
+  getPaneShortcutArgKind,
+  getPluginCommandShortcutArgKind,
+  type RootShortcutArgKind,
+} from "../routes/root/shortcuts";
+
+/** Server cap on `/assist/command` inventories. */
+const ASSIST_INVENTORY_LIMIT = 150;
+
+interface AssistInventorySource {
+  commands: readonly Command[];
+  pluginCommands: readonly CommandDef[];
+  paneTemplates: readonly PaneTemplateDef[];
+  limit?: number;
+}
+
+function describeArg(
+  kind: RootShortcutArgKind | null,
+  placeholder: string | undefined,
+): AssistCommandDescriptor["arg"] {
+  if (!kind) return undefined;
+  const trimmed = placeholder?.trim();
+  return trimmed ? { kind, placeholder: trimmed } : { kind };
+}
+
+function describe(
+  prefix: string,
+  name: string,
+  description: string | undefined,
+  arg: AssistCommandDescriptor["arg"],
+): AssistCommandDescriptor | null {
+  const normalizedPrefix = prefix.trim().toUpperCase();
+  const normalizedName = name.trim();
+  if (!normalizedPrefix || !normalizedName) return null;
+  const normalizedDescription = description?.trim();
+  return {
+    prefix: normalizedPrefix,
+    name: normalizedName,
+    ...(normalizedDescription ? { description: normalizedDescription } : {}),
+    ...(arg ? { arg } : {}),
+  };
+}
+
+/**
+ * Flattens the command bar's prefix language into the shape `/assist/command`
+ * expects. Sources are visited in the same order the shortcut parser resolves
+ * them (built-in commands, plugin commands, pane templates), so the entry kept
+ * for a duplicated prefix is the one the bar would actually run. Aliases are
+ * omitted: the assistant should teach one canonical prefix per command.
+ */
+export function buildAssistCommandInventory({
+  commands,
+  pluginCommands,
+  paneTemplates,
+  limit = ASSIST_INVENTORY_LIMIT,
+}: AssistInventorySource): AssistCommandDescriptor[] {
+  const descriptors: Array<AssistCommandDescriptor | null> = [
+    ...commands.map((command) => describe(
+      command.prefix,
+      command.label,
+      command.description,
+      describeArg(getCommandShortcutArgKind(command), command.argPlaceholder),
+    )),
+    ...pluginCommands.map((command) => describe(
+      command.shortcut ?? "",
+      command.label,
+      command.description,
+      describeArg(getPluginCommandShortcutArgKind(command), command.shortcutArg?.placeholder),
+    )),
+    ...paneTemplates.map((template) => describe(
+      template.shortcut?.prefix ?? "",
+      getPaneTemplateDisplayLabel(template),
+      template.description,
+      describeArg(getPaneShortcutArgKind(template), template.shortcut?.argPlaceholder),
+    )),
+  ];
+
+  const seenPrefixes = new Set<string>();
+  const inventory: AssistCommandDescriptor[] = [];
+  for (const descriptor of descriptors) {
+    if (!descriptor || seenPrefixes.has(descriptor.prefix)) continue;
+    seenPrefixes.add(descriptor.prefix);
+    inventory.push(descriptor);
+    if (inventory.length >= limit) break;
+  }
+  return inventory;
+}

package/src/components/command-bar/assist/model.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildAssistResultItems,
+  shouldAutoAskAssist,
+  shouldShowAssistRow,
+  type AssistRequestState,
+} from "./model";
+
+const handlers = {
+  onAsk: () => {},
+  onSignUp: () => {},
+  onRunCandidate: () => {},
+};
+
+function labels(
+  state: AssistRequestState,
+  options?: { query?: string; enabled?: boolean; auto?: boolean },
+): string[] {
+  return buildAssistResultItems({
+    ...handlers,
+    query: options?.query ?? "chart nvidia vs amd",
+    enabled: options?.enabled ?? true,
+    auto: options?.auto ?? true,
+    state,
+  }).map((item) => item.label);
+}
+
+describe("shouldAutoAskAssist", () => {
+  test("stays out of the way while the user speaks the command language", () => {
+    expect(shouldAutoAskAssist({ query: "chart nvidia vs amd", hasShortcutIntent: false })).toBe(true);
+    expect(shouldAutoAskAssist({ query: "nvda", hasShortcutIntent: false })).toBe(true);
+    // A recognized prefix — with or without an argument — is not a question.
+    expect(shouldAutoAskAssist({ query: "T NVDA", hasShortcutIntent: true })).toBe(false);
+    expect(shouldAutoAskAssist({ query: "gg", hasShortcutIntent: false })).toBe(false);
+    expect(shouldAutoAskAssist({ query: "   ", hasShortcutIntent: false })).toBe(false);
+  });
+});
+
+describe("shouldShowAssistRow", () => {
+  test("offers the AI on natural language, or on any dead end", () => {
+    expect(shouldShowAssistRow({ query: "chart nvidia vs amd", resultCount: 4 })).toBe(true);
+    expect(shouldShowAssistRow({ query: "zzzz", resultCount: 0 })).toBe(true);
+    expect(shouldShowAssistRow({ query: "chart", resultCount: 3 })).toBe(false);
+    expect(shouldShowAssistRow({ query: "  ", resultCount: 0 })).toBe(false);
+    // Trailing whitespace alone is not a second word.
+    expect(shouldShowAssistRow({ query: "chart ", resultCount: 3 })).toBe(false);
+  });
+});
+
+describe("buildAssistResultItems", () => {
+  test("routes signed-out users to sign up instead of the request", () => {
+    expect(labels({ status: "idle" }, { enabled: false })).toEqual(["Ask AI — sign up to enable"]);
+  });
+
+  test("renders each state of the request", () => {
+    expect(labels({ status: "idle" })).toEqual(["Thinking…"]);
+    expect(labels({ status: "idle" }, { auto: false })).toEqual([]);
+    expect(labels({ status: "loading", query: "chart nvidia vs amd", source: "auto" }))
+      .toEqual(["Thinking…"]);
+    expect(labels({ status: "answered", query: "chart nvidia vs amd", source: "auto", candidates: [] }))
+      .toEqual(["No command found — try HELP"]);
+  });
+
+  test("keeps failures silent unless the user asked for the answer", () => {
+    const failure = { status: "error", query: "chart nvidia vs amd", kind: "rate-limited" } as const;
+    expect(labels({ ...failure, source: "auto" })).toEqual([]);
+    expect(labels({ ...failure, source: "explicit" }))
+      .toEqual(["Rate limited — try again in a minute"]);
+  });
+
+  test("shows candidates input-first and runs the exact command-bar text", () => {
+    const runs: Array<[string, string | undefined]> = [];
+    const items = buildAssistResultItems({
+      ...handlers,
+      onRunCandidate: (input, prefix) => runs.push([input, prefix]),
+      query: "chart nvidia vs amd",
+      enabled: true,
+      auto: true,
+      state: {
+        status: "answered",
+        query: "chart nvidia vs amd",
+        source: "auto",
+        candidates: [{ input: "G NVDA AMD", title: "Chart NVDA vs AMD", prefix: "G", confidence: 0.9 }],
+      },
+    });
+
+    expect(items[0]?.label).toBe("G NVDA AMD — Chart NVDA vs AMD");
+    // The marker rides the trailing column instead of shifting the label.
+    expect(items[0]?.right).toBe("✦");
+    expect(items[0]?.accent).toBe(true);
+    items[0]?.action();
+    expect(runs).toEqual([["G NVDA AMD", "G"]]);
+  });
+
+  test("ignores an answer that belongs to an earlier query", () => {
+    const state: AssistRequestState = {
+      status: "answered",
+      query: "chart nvidia",
+      source: "auto",
+      candidates: [{ input: "G NVDA", title: "Chart NVDA", prefix: "G", confidence: 0.9 }],
+    };
+    expect(labels(state, { query: "chart nvidia vs amd" })).toEqual(["Thinking…"]);
+  });
+});

package/src/components/command-bar/assist/model.ts

@@ -0,0 +1,169 @@
+import type { AssistCommandCandidate } from "../../../api-client";
+import { t } from "../../../i18n";
+import type { ResultItem } from "../list/model";
+
+/** Marker shown on every AI-resolved row, matching the AI plugin's iconography. */
+const ASSIST_GLYPH = "✦";
+
+/** Category heading the assist rows group under; sorted first by the view model. */
+const ASSIST_CATEGORY = "Ask AI";
+
+/** Shorter queries are almost always a half-typed prefix, not a question. */
+const ASSIST_AUTO_MIN_QUERY_LENGTH = 3;
+
+export type AssistErrorKind = "unavailable" | "rate-limited" | "failed";
+
+/** Whether the request was started by the debounce or by the user hitting Enter. */
+export type AssistRequestSource = "auto" | "explicit";
+
+export type AssistRequestState =
+  | { status: "idle" }
+  | { status: "loading"; query: string; source: AssistRequestSource }
+  | { status: "answered"; query: string; source: AssistRequestSource; candidates: AssistCommandCandidate[] }
+  | { status: "error"; query: string; source: AssistRequestSource; kind: AssistErrorKind };
+
+export interface AssistRowHandlers {
+  /** Signed in with a verified email, i.e. `/assist/command` will answer. */
+  enabled: boolean;
+  /** The query qualifies for a background ask, so the section is expected. */
+  auto: boolean;
+  state: AssistRequestState;
+  onAsk: () => void;
+  onSignUp: () => void;
+  onRunCandidate: (input: string, prefix?: string) => void;
+}
+
+/**
+ * Whether the query should be answered by the AI without being asked for it.
+ * Anything the prefix parser recognizes is the user speaking the command
+ * language, and very short input is a prefix mid-typing rather than a question.
+ */
+export function shouldAutoAskAssist({
+  query,
+  hasShortcutIntent,
+}: {
+  query: string;
+  hasShortcutIntent: boolean;
+}): boolean {
+  if (hasShortcutIntent) return false;
+  return query.trim().length >= ASSIST_AUTO_MIN_QUERY_LENGTH;
+}
+
+/**
+ * Whether a signed-out user is offered the sign-up row. Multi-word input reads
+ * as natural language rather than a prefix, and a query with no local matches
+ * is a dead end either way.
+ */
+export function shouldShowAssistRow({
+  query,
+  resultCount,
+}: {
+  query: string;
+  resultCount: number;
+}): boolean {
+  const trimmed = query.trim();
+  if (!trimmed) return false;
+  if (/\s/.test(trimmed)) return true;
+  return resultCount === 0;
+}
+
+function assistErrorLabel(kind: AssistErrorKind): string {
+  if (kind === "unavailable") return t("AI assist unavailable");
+  if (kind === "rate-limited") return t("Rate limited — try again in a minute");
+  return t("AI assist failed — try again");
+}
+
+function assistRow(options: {
+  id: string;
+  label: string;
+  kind: ResultItem["kind"];
+  action?: () => void;
+  defaultSelectable?: boolean;
+}): ResultItem {
+  return {
+    id: options.id,
+    label: options.label,
+    detail: "",
+    category: ASSIST_CATEGORY,
+    kind: options.kind,
+    // Right-aligned like a shortcut, so the glyph never crowds the answer.
+    right: ASSIST_GLYPH,
+    accent: true,
+    disabled: !options.action,
+    defaultSelectable: options.defaultSelectable,
+    action: options.action ?? (() => {}),
+  };
+}
+
+/**
+ * Rows for the assist section. They always land in their own category, which
+ * sorts to the top of the list, so the answer to what the user typed leads the
+ * results and plain Enter runs the AI's best guess.
+ */
+export function buildAssistResultItems({
+  query,
+  enabled,
+  auto,
+  state,
+  onAsk,
+  onSignUp,
+  onRunCandidate,
+}: AssistRowHandlers & { query: string }): ResultItem[] {
+  const trimmed = query.trim();
+  if (!trimmed) return [];
+
+  if (!enabled) {
+    // An offer, not an answer: it leads the list without ever taking the Enter
+    // that belongs to the local match the user is looking at.
+    return [assistRow({
+      id: "assist:sign-up",
+      label: t("Ask AI — sign up to enable"),
+      kind: "action",
+      action: onSignUp,
+      defaultSelectable: false,
+    })];
+  }
+
+  // A response only describes the query it was asked about.
+  const active = state.status !== "idle" && state.query === trimmed ? state : null;
+
+  if (!active) {
+    if (!auto) return [];
+    // Still inside the debounce window; activating the row skips the wait.
+    return [assistRow({ id: "assist:pending", label: t("Thinking…"), kind: "info", action: onAsk })];
+  }
+
+  if (active.status === "loading") {
+    // Selected by default while it leads the list, so Enter has to mean
+    // something: it claims the answer that is already on the wire.
+    return [assistRow({ id: "assist:loading", label: t("Thinking…"), kind: "info", action: onAsk })];
+  }
+
+  if (active.status === "error") {
+    // A background failure is not worth a row the user never asked for.
+    if (active.source === "auto") return [];
+    return [assistRow({
+      id: "assist:error",
+      label: assistErrorLabel(active.kind),
+      kind: "info",
+      action: onAsk,
+      defaultSelectable: false,
+    })];
+  }
+
+  if (active.candidates.length === 0) {
+    return [assistRow({
+      id: "assist:no-command",
+      label: t("No command found — try HELP"),
+      kind: "info",
+    })];
+  }
+
+  // Input first: the row doubles as a lesson in the prefix language.
+  return active.candidates.map((candidate, index) => assistRow({
+    id: `assist:candidate:${index}:${candidate.input}`,
+    label: `${candidate.input} — ${candidate.title}`,
+    kind: "action",
+    action: () => onRunCandidate(candidate.input, candidate.prefix),
+  }));
+}