gloomberb 0.1.0 → 0.3.1

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

@@ -0,0 +1,185 @@
+import { matchPrefix } from "./command-registry";
+export { rankTickerSearchItems } from "../../utils/ticker-search";
+
+export type CommandBarMode = "default" | "search" | "themes" | "plugins" | "layout" | "new-pane" | "direct-command";
+
+export interface CommandBarModeInfo {
+  kind: CommandBarMode;
+  badge: string;
+  hint: string;
+}
+
+export interface CommandBarModeStripEntry {
+  prefix: string;
+  label: string;
+  active: boolean;
+}
+
+export interface CommandBarFooterHints {
+  left: string;
+  right: string;
+}
+
+export interface CommandBarSection<T> {
+  category: string;
+  items: T[];
+}
+
+export interface CommandBarItemView {
+  id: string;
+  label: string;
+  detail: string;
+  category: string;
+  kind: "command" | "ticker" | "search" | "theme" | "plugin" | "action" | "info";
+  right?: string;
+  checked?: boolean;
+  current?: boolean;
+}
+
+export interface CommandBarRowPresentation {
+  glyph: string;
+  label: string;
+  trailing: string;
+  selected: boolean;
+  primaryMuted: boolean;
+}
+
+const MODE_STRIP_ENTRIES = [
+  { prefix: "T", label: "Search ticker", kind: "search" },
+  { prefix: "TH", label: "Change theme", kind: "themes" },
+  { prefix: "PL", label: "Toggle plugins", kind: "plugins" },
+  { prefix: "LAY", label: "Layout actions", kind: "layout" },
+  { prefix: "NP", label: "New pane", kind: "new-pane" },
+] as const;
+
+export function resolveCommandBarMode(query: string): CommandBarModeInfo {
+  const match = matchPrefix(query);
+
+  if (!query.trim()) {
+    return { kind: "default", badge: "BROWSE", hint: "Type a command, ticker, or prefix" };
+  }
+
+  if (!match) {
+    return { kind: "default", badge: "FILTER", hint: `Filtering for "${query.trim()}"` };
+  }
+
+  switch (match.command.id) {
+    case "search-ticker":
+      return { kind: "search", badge: "SEARCH", hint: "Search Yahoo Finance and broker-backed symbols" };
+    case "theme":
+      return { kind: "themes", badge: "THEMES", hint: "Preview with arrows, Enter to save, Esc to revert" };
+    case "plugins":
+      return { kind: "plugins", badge: "PLUGINS", hint: "Toggle plugins without leaving the list" };
+    case "layout":
+      return { kind: "layout", badge: "LAYOUT", hint: "Organize panes, history, and saved layouts" };
+    case "new-pane":
+      return { kind: "new-pane", badge: "NEW PANE", hint: "Create plugin-defined panes for the current workspace" };
+    default:
+      return { kind: "direct-command", badge: "COMMAND", hint: `Run ${match.command.label}` };
+  }
+}
+
+export function getModeStrip(mode: CommandBarMode): CommandBarModeStripEntry[] {
+  return MODE_STRIP_ENTRIES.map((entry) => ({
+    prefix: entry.prefix,
+    label: entry.label,
+    active: entry.kind === mode,
+  }));
+}
+
+export function buildSections<T extends { category: string }>(items: T[]): Array<CommandBarSection<T>> {
+  const sections: Array<CommandBarSection<T>> = [];
+  for (const item of items) {
+    let section = sections.find((candidate) => candidate.category === item.category);
+    if (!section) {
+      section = { category: item.category, items: [] };
+      sections.push(section);
+    }
+    section.items.push(item);
+  }
+  return sections
+    .map((section, index) => ({ section, index }))
+    .sort((a, b) => {
+      const priorityDiff = getCategoryPriority(a.section.category) - getCategoryPriority(b.section.category);
+      return priorityDiff !== 0 ? priorityDiff : a.index - b.index;
+    })
+    .map(({ section }) => section);
+}
+
+export function getFooterHints(mode: CommandBarMode, isNarrow: boolean): CommandBarFooterHints {
+  const moveAndSelect = isNarrow ? "up/down move  enter select" : "up/down move  enter select";
+  if (mode === "plugins") {
+    return {
+      left: isNarrow ? "space toggle" : `${moveAndSelect}  space toggle`,
+      right: "esc close",
+    };
+  }
+  if (mode === "layout") {
+    return { left: moveAndSelect, right: "esc close" };
+  }
+  if (mode === "new-pane") {
+    return { left: moveAndSelect, right: "esc close" };
+  }
+  return { left: moveAndSelect, right: "esc close" };
+}
+
+export function getEmptyState(mode: CommandBarMode, query: string, searchQuery?: string): { label: string; detail: string } {
+  switch (mode) {
+    case "search":
+      if (!searchQuery) {
+        return { label: "Type a ticker symbol", detail: "Search Yahoo Finance and connected brokers" };
+      }
+      return { label: `No matches for "${searchQuery}"`, detail: "Try a symbol, company name, or exchange variant" };
+    case "plugins":
+      return { label: "No plugins match", detail: query.trim() || "Toggleable plugins will appear here" };
+    case "themes":
+      return { label: "No themes match", detail: query.trim() || "Installed themes will appear here" };
+    case "layout":
+      return { label: "No layout actions match", detail: query.trim() || "Focused-pane and layout actions will appear here" };
+    case "new-pane":
+      return { label: "No pane templates match", detail: query.trim() || "Plugin-defined pane templates will appear here" };
+    default:
+      if (query.trim()) {
+        return { label: `No matches for "${query.trim()}"`, detail: "Try a ticker, command name, or prefix" };
+      }
+      return { label: "No results yet", detail: "Recent tickers and suggested commands will appear here" };
+  }
+}
+
+export function getRowPresentation(item: CommandBarItemView, selected: boolean, showTrailing: boolean): CommandBarRowPresentation {
+  const glyph = selected ? "\u203a" : " ";
+  const primaryMuted = item.kind === "plugin" && !item.checked;
+  let trailing = "";
+
+  if (showTrailing) {
+    if (item.current) trailing = "current";
+    else if (item.kind === "plugin") trailing = item.checked ? "on" : "off";
+    else trailing = item.right || "";
+  }
+
+  return {
+    glyph,
+    label: item.label,
+    trailing,
+    selected,
+    primaryMuted,
+  };
+}
+
+export function truncateText(text: string, width: number): string {
+  if (width <= 0) return "";
+  if (text.length <= width) return text;
+  if (width <= 3) return ".".repeat(width);
+  return `${text.slice(0, width - 3)}...`;
+}
+
+function getCategoryPriority(category: string): number {
+  const normalized = category.trim().toLowerCase();
+  if (normalized === "saved") return -40;
+  if (normalized === "primary listing") return -30;
+  if (normalized === "other listings") return -20;
+  if (normalized === "funds & derivatives") return -10;
+  if (normalized.includes("danger")) return 900;
+  if (normalized.includes("debug")) return 910;
+  return 0;
+}

package/src/components/command-bar/workflow-ops.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test";
+import { createDefaultConfig } from "../../types/config";
+import { createInitialState } from "../../state/app-context";
+import { createTestDataProvider } from "../../test-support/data-provider";
+import { createPaneTemplateOrThrow } from "./workflow-ops";
+
+function makeDataProvider() {
+  return createTestDataProvider({ id: "test" });
+}
+
+function makeTickerRepository() {
+  return {
+    getTicker: async () => null,
+    saveTicker: async () => {},
+    createTicker: async () => { throw new Error("unused"); },
+    deleteTicker: async () => {},
+    getAllTickers: async () => [],
+  };
+}
+
+describe("createPaneTemplateOrThrow", () => {
+  test("treats createInstance null as cancellation and does not create a pane", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-workflow-ops-test");
+    const state = createInitialState(config);
+    const buildCalls: unknown[] = [];
+    const placeCalls: unknown[] = [];
+
+    await createPaneTemplateOrThrow("cancelled-pane", undefined, {
+      dataProvider: makeDataProvider() as any,
+      tickerRepository: makeTickerRepository() as any,
+      dispatch: () => {},
+      getState: () => state,
+      pluginRegistry: {
+        paneTemplates: new Map([
+          ["cancelled-pane", {
+            id: "cancelled-pane",
+            paneId: "test-pane",
+            label: "Cancelled Pane",
+            description: "Should cancel cleanly",
+            createInstance: async () => null,
+          }],
+        ]),
+        panes: new Map([
+          ["test-pane", {
+            id: "test-pane",
+            name: "Test Pane",
+            component: () => null,
+            defaultPosition: "right",
+          }],
+        ]),
+        getPaneTemplatePluginId: () => undefined,
+        events: { emit: () => {} },
+      } as any,
+      buildPaneInstance: (...args) => {
+        buildCalls.push(args);
+        return {
+          instanceId: "test-pane:1",
+          paneId: "test-pane",
+          title: "Broken Pane",
+        } as any;
+      },
+      placePaneInstance: (...args) => {
+        placeCalls.push(args);
+      },
+    });
+
+    expect(buildCalls).toHaveLength(0);
+    expect(placeCalls).toHaveLength(0);
+  });
+});

package/src/components/command-bar/workflow-ops.ts

@@ -0,0 +1,433 @@
+import type { Dispatch } from "react";
+import { type LayoutConfig, type PaneBinding, type PaneInstanceConfig } from "../../types/config";
+import type { DataProvider } from "../../types/data-provider";
+import type { Portfolio, TickerRecord, Watchlist } from "../../types/ticker";
+import type { PaneSettingField, PaneTemplateContext, PaneTemplateCreateOptions, PaneTemplateInstanceConfig, PaneTemplateDef } from "../../types/plugin";
+import { getFocusedCollectionId, getFocusedTickerSymbol, type AppAction, type AppState } from "../../state/app-context";
+import type { PluginRegistry } from "../../plugins/registry";
+import type { TickerRepository } from "../../data/ticker-repository";
+import { resolveTickerSearch, upsertTickerFromSearchResult } from "../../utils/ticker-search";
+import { formatTickerListInput, parseTickerListInput } from "../../utils/ticker-list";
+import { updatePaneInstance, setPaneSettings } from "../../pane-settings";
+import {
+  buildComparisonChartPaneTitle,
+  COMPARISON_CHART_PANE_ID,
+} from "../../plugins/builtin/comparison-chart";
+
+export interface SharedWorkflowDeps {
+  dataProvider: DataProvider;
+  tickerRepository: TickerRepository;
+  pluginRegistry: PluginRegistry;
+  dispatch: Dispatch<AppAction>;
+  getState: () => AppState;
+}
+
+interface CreatePaneTemplateDeps extends SharedWorkflowDeps {
+  buildPaneInstance: (
+    paneType: string,
+    options?: {
+      title?: string;
+      binding?: PaneBinding;
+      params?: Record<string, string>;
+      settings?: Record<string, unknown>;
+      instanceId?: string;
+    },
+  ) => PaneInstanceConfig | null;
+  placePaneInstance: (
+    instance: PaneInstanceConfig,
+    paneDef: NonNullable<ReturnType<PluginRegistry["panes"]["get"]>>,
+    options?: PaneTemplateInstanceConfig,
+  ) => void;
+}
+
+interface ApplyPaneSettingDeps extends SharedWorkflowDeps {
+  persistLayout: (layout: LayoutConfig, options?: { pushHistory?: boolean }) => void;
+}
+
+export type CollectionKind = "watchlist" | "portfolio";
+export type CollectionMembershipAction = "add" | "remove";
+
+export interface CollectionTargetOption {
+  id: string;
+  label: string;
+  description?: string;
+}
+
+export interface ResolvedTickerInput {
+  symbol: string;
+  ticker: TickerRecord;
+  created: boolean;
+  source: "local" | "provider";
+}
+
+function getTickerSearchContext(state: AppState, collectionId: string | null) {
+  const activePortfolio = state.config.portfolios.find((portfolio) => portfolio.id === collectionId);
+  return {
+    preferBroker: true,
+    brokerId: activePortfolio?.brokerId,
+    brokerInstanceId: activePortfolio?.brokerInstanceId,
+  };
+}
+
+async function materializeResolvedTicker(
+  resolvedTicker: NonNullable<Awaited<ReturnType<typeof resolveTickerSearch>>>,
+  deps: SharedWorkflowDeps,
+): Promise<ResolvedTickerInput> {
+  if (resolvedTicker.kind === "local") {
+    return {
+      symbol: resolvedTicker.ticker.metadata.ticker,
+      ticker: resolvedTicker.ticker,
+      created: false,
+      source: "local",
+    };
+  }
+
+  const { ticker, created } = await upsertTickerFromSearchResult(
+    deps.tickerRepository,
+    resolvedTicker.result,
+  );
+  deps.dispatch({ type: "UPDATE_TICKER", ticker });
+  if (created) {
+    deps.pluginRegistry.events.emit("ticker:added", {
+      symbol: ticker.metadata.ticker,
+      ticker,
+    });
+  }
+
+  return {
+    symbol: ticker.metadata.ticker,
+    ticker,
+    created,
+    source: "provider",
+  };
+}
+
+function getCollectionOptions(
+  state: AppState,
+  kind: CollectionKind,
+): Array<Portfolio | Watchlist> {
+  if (kind === "watchlist") {
+    return state.config.watchlists;
+  }
+  return state.config.portfolios.filter((portfolio) => !portfolio.brokerId && !portfolio.brokerInstanceId);
+}
+
+export function getCollectionTargetOptions(
+  state: AppState,
+  kind: CollectionKind,
+  action: CollectionMembershipAction,
+  ticker: TickerRecord | null,
+): CollectionTargetOption[] {
+  const collections = getCollectionOptions(state, kind);
+  const membershipIds = ticker
+    ? new Set(kind === "watchlist" ? ticker.metadata.watchlists : ticker.metadata.portfolios)
+    : new Set<string>();
+
+  return collections
+    .filter((collection) => {
+      if (!ticker) return true;
+      const isMember = membershipIds.has(collection.id);
+      return action === "add" ? !isMember : isMember;
+    })
+    .map((collection) => ({
+      id: collection.id,
+      label: collection.name,
+      description: action === "add"
+        ? `Add to "${collection.name}"`
+        : `Remove from "${collection.name}"`,
+    }));
+}
+
+export function resolvePreferredCollectionTarget(
+  state: AppState,
+  kind: CollectionKind,
+  activeCollectionId: string | null,
+  action: CollectionMembershipAction,
+  ticker: TickerRecord | null,
+): string | null {
+  if (!activeCollectionId) return null;
+  const options = getCollectionTargetOptions(state, kind, action, ticker);
+  return options.some((option) => option.id === activeCollectionId) ? activeCollectionId : null;
+}
+
+export async function resolveTickerInput(
+  rawInput: string | undefined,
+  activeTicker: string | null,
+  collectionId: string | null,
+  deps: SharedWorkflowDeps,
+): Promise<ResolvedTickerInput | null> {
+  const state = deps.getState();
+  const resolvedTicker = await resolveTickerSearch({
+    query: rawInput,
+    activeTicker,
+    tickers: state.tickers,
+    dataProvider: deps.dataProvider,
+    searchContext: getTickerSearchContext(state, collectionId),
+  });
+  if (!resolvedTicker) return null;
+  return materializeResolvedTicker(resolvedTicker, deps);
+}
+
+export async function resolveTickerInputOrThrow(
+  rawInput: string | undefined,
+  activeTicker: string | null,
+  collectionId: string | null,
+  deps: SharedWorkflowDeps,
+): Promise<ResolvedTickerInput> {
+  const resolved = await resolveTickerInput(rawInput, activeTicker, collectionId, deps);
+  if (!resolved) {
+    throw new Error(`No ticker match found for "${rawInput ?? activeTicker ?? ""}".`);
+  }
+  return resolved;
+}
+
+export async function applyCollectionMembershipChange(
+  ticker: TickerRecord,
+  kind: CollectionKind,
+  action: CollectionMembershipAction,
+  collectionId: string,
+  deps: SharedWorkflowDeps,
+): Promise<{ changed: boolean; ticker: TickerRecord }> {
+  const field = kind === "watchlist" ? "watchlists" : "portfolios";
+  const currentValues = ticker.metadata[field];
+  const nextValues = action === "add"
+    ? (currentValues.includes(collectionId) ? currentValues : [...currentValues, collectionId])
+    : currentValues.filter((entry) => entry !== collectionId);
+
+  if (nextValues.length === currentValues.length && nextValues.every((entry, index) => entry === currentValues[index])) {
+    return { changed: false, ticker };
+  }
+
+  const nextTicker: TickerRecord = {
+    ...ticker,
+    metadata: {
+      ...ticker.metadata,
+      [field]: nextValues,
+    },
+  };
+  await deps.tickerRepository.saveTicker(nextTicker);
+  deps.dispatch({ type: "UPDATE_TICKER", ticker: nextTicker });
+  return { changed: true, ticker: nextTicker };
+}
+
+export async function resolveTickerListInput(
+  rawInput: string,
+  collectionId: string | null,
+  deps: SharedWorkflowDeps,
+): Promise<string[]> {
+  const tokens = parseTickerListInput(rawInput);
+  const symbols: string[] = [];
+  const seen = new Set<string>();
+
+  for (const token of tokens) {
+    const resolvedTicker = await resolveTickerInputOrThrow(token, null, collectionId, deps);
+    const symbol = resolvedTicker.symbol;
+
+    if (seen.has(symbol)) continue;
+    seen.add(symbol);
+    symbols.push(symbol);
+  }
+
+  return symbols;
+}
+
+async function resolvePaneTemplateOptions(
+  template: PaneTemplateDef,
+  options: PaneTemplateCreateOptions | undefined,
+  deps: SharedWorkflowDeps,
+): Promise<{
+  context: PaneTemplateContext;
+  resolvedOptions: PaneTemplateCreateOptions | undefined;
+}> {
+  const state = deps.getState();
+  const baseContext: PaneTemplateContext = {
+    config: state.config,
+    layout: state.config.layout,
+    focusedPaneId: state.focusedPaneId,
+    activeTicker: getFocusedTickerSymbol(state),
+    activeCollectionId: getFocusedCollectionId(state),
+  };
+
+  let resolvedOptions = options;
+  if (template.shortcut?.argPlaceholder === "ticker") {
+    const resolvedTicker = await resolveTickerInputOrThrow(
+      resolvedOptions?.arg,
+      baseContext.activeTicker,
+      baseContext.activeCollectionId,
+      deps,
+    );
+    resolvedOptions = {
+      ...resolvedOptions,
+      symbol: resolvedTicker.symbol,
+      ticker: resolvedTicker.ticker,
+      searchResult: null,
+    };
+  } else if (template.shortcut?.argPlaceholder === "tickers") {
+    const rawInput = resolvedOptions?.arg ?? resolvedOptions?.values?.tickers ?? "";
+    const symbols = await resolveTickerListInput(rawInput, baseContext.activeCollectionId, deps);
+    resolvedOptions = {
+      ...resolvedOptions,
+      arg: rawInput,
+      symbols,
+    };
+  }
+
+  const context: PaneTemplateContext = {
+    ...baseContext,
+    activeTicker: resolvedOptions?.symbol ?? baseContext.activeTicker,
+  };
+
+  return {
+    context,
+    resolvedOptions,
+  };
+}
+
+export async function createPaneTemplateOrThrow(
+  templateId: string,
+  options: PaneTemplateCreateOptions | undefined,
+  deps: CreatePaneTemplateDeps,
+): Promise<void> {
+  const template = deps.pluginRegistry.paneTemplates.get(templateId);
+  if (!template) {
+    throw new Error(`Unknown pane template "${templateId}".`);
+  }
+
+  const state = deps.getState();
+  const pluginId = deps.pluginRegistry.getPaneTemplatePluginId(templateId);
+  if (pluginId && state.config.disabledPlugins.includes(pluginId)) {
+    throw new Error("Enable this plugin before creating its pane.");
+  }
+
+  const { context, resolvedOptions } = await resolvePaneTemplateOptions(template, options, deps);
+
+  if (template.canCreate && !template.canCreate(context, resolvedOptions)) {
+    throw new Error(`Can't create ${template.label.toLowerCase()} right now.`);
+  }
+
+  const createInstanceResult = await template.createInstance?.(context, resolvedOptions);
+  if (createInstanceResult === null) {
+    return;
+  }
+  const spec = createInstanceResult ?? {};
+
+  const paneDef = deps.pluginRegistry.panes.get(template.paneId);
+  if (!paneDef) {
+    throw new Error(`Unknown pane "${template.paneId}".`);
+  }
+
+  const instance = deps.buildPaneInstance(template.paneId, {
+    title: spec.title,
+    binding: spec.binding,
+    params: spec.params,
+    settings: spec.settings,
+  });
+  if (!instance) {
+    throw new Error("Open a matching ticker or collection context first.");
+  }
+
+  deps.placePaneInstance(instance, paneDef, spec);
+}
+
+export async function applyPaneSettingFieldValue(
+  targetId: string,
+  field: PaneSettingField,
+  value: unknown,
+  deps: ApplyPaneSettingDeps,
+  options?: { pushHistory?: boolean },
+): Promise<void> {
+  const descriptor = deps.pluginRegistry.resolvePaneSettings(targetId);
+  if (!descriptor) {
+    throw new Error("This pane does not expose settings.");
+  }
+
+  const state = deps.getState();
+  const shouldPushHistory = options?.pushHistory !== false;
+
+  if (descriptor.pane.paneId === "quote-monitor" && field.key === "symbol") {
+    const rawQuery = typeof value === "string" ? value.trim() : "";
+    const resolvedTicker = await resolveTickerSearch({
+      query: rawQuery,
+      activeTicker: null,
+      tickers: state.tickers,
+      dataProvider: deps.dataProvider,
+    });
+    if (!resolvedTicker) {
+      throw new Error(`No ticker match found for "${rawQuery}".`);
+    }
+
+    const symbol = resolvedTicker.kind === "local"
+      ? resolvedTicker.ticker.metadata.ticker
+      : resolvedTicker.symbol;
+
+    if (resolvedTicker.kind === "provider") {
+      const { ticker, created } = await upsertTickerFromSearchResult(
+        deps.tickerRepository,
+        resolvedTicker.result,
+      );
+      deps.dispatch({ type: "UPDATE_TICKER", ticker });
+      if (created) {
+        deps.pluginRegistry.events.emit("ticker:added", {
+          symbol: ticker.metadata.ticker,
+          ticker,
+        });
+      }
+    }
+
+    const nextLayout = updatePaneInstance(state.config.layout, targetId, (instance) => ({
+      ...instance,
+      title: symbol,
+      binding: { kind: "fixed", symbol },
+      settings: {
+        ...(instance.settings ?? {}),
+        symbol,
+      },
+    }));
+    deps.persistLayout(nextLayout, { pushHistory: shouldPushHistory });
+    return;
+  }
+
+  if (descriptor.pane.paneId === COMPARISON_CHART_PANE_ID && field.key === "symbolsText") {
+    const rawInput = typeof value === "string" ? value : "";
+    const symbols = await resolveTickerListInput(
+      rawInput,
+      descriptor.context.activeCollectionId,
+      deps,
+    );
+    const nextLayout = updatePaneInstance(state.config.layout, targetId, (instance) => ({
+      ...instance,
+      title: buildComparisonChartPaneTitle(symbols),
+      settings: {
+        ...(instance.settings ?? {}),
+        symbols,
+        symbolsText: formatTickerListInput(symbols),
+      },
+    }));
+    deps.persistLayout(nextLayout, { pushHistory: shouldPushHistory });
+    return;
+  }
+
+  const nextSettings = {
+    ...descriptor.context.settings,
+    [field.key]: value,
+  };
+
+  if (descriptor.pane.paneId === "portfolio-list" && field.key === "hideTabs" && value === true) {
+    const lockedCollectionId = typeof descriptor.context.paneState.collectionId === "string"
+      ? descriptor.context.paneState.collectionId
+      : descriptor.context.activeCollectionId;
+    if (lockedCollectionId) {
+      nextSettings.lockedCollectionId = lockedCollectionId;
+    }
+  }
+
+  if (descriptor.pane.paneId === "ticker-detail" && field.key === "hideTabs" && value === true) {
+    const lockedTabId = typeof descriptor.context.paneState.activeTabId === "string"
+      ? descriptor.context.paneState.activeTabId
+      : "overview";
+    nextSettings.lockedTabId = lockedTabId;
+  }
+
+  const nextLayout = setPaneSettings(state.config.layout, targetId, nextSettings);
+  deps.persistLayout(nextLayout, { pushHistory: shouldPushHistory });
+}