gloomberb 0.5.1 → 0.6.1

package/src/capabilities/registry.ts

@@ -0,0 +1,131 @@
+import {
+  recordSchema,
+  type CapabilityManifest,
+  type CapabilityOperationManifest,
+  type CapabilityRegistryOptions,
+  type PluginCapability,
+  type RegisteredCapability,
+} from "./types";
+
+interface SubscriptionEntry {
+  capabilityId: string;
+  dispose: () => void;
+}
+
+export class CapabilityRegistry {
+  private readonly capabilities = new Map<string, RegisteredCapability>();
+  private readonly subscriptions = new Map<string, SubscriptionEntry>();
+  private nextSubscriptionId = 1;
+
+  constructor(private readonly options: CapabilityRegistryOptions = {}) {}
+
+  register(pluginId: string, capability: PluginCapability): () => void {
+    const existing = this.capabilities.get(capability.id);
+    if (existing) {
+      throw new Error(`Capability "${capability.id}" already registered by plugin "${existing.pluginId}".`);
+    }
+    this.capabilities.set(capability.id, { pluginId, capability });
+    return () => {
+      this.capabilities.delete(capability.id);
+      for (const [subscriptionId, entry] of this.subscriptions) {
+        if (entry.capabilityId === capability.id) {
+          entry.dispose();
+          this.subscriptions.delete(subscriptionId);
+        }
+      }
+    };
+  }
+
+  get(id: string): RegisteredCapability | undefined {
+    return this.capabilities.get(id);
+  }
+
+  list(kind?: string): RegisteredCapability[] {
+    return [...this.capabilities.values()]
+      .filter((entry) => !kind || entry.capability.kind === kind)
+      .filter((entry) => this.isEnabled(entry))
+      .sort((left, right) => (
+        (left.capability.priority ?? 1000) - (right.capability.priority ?? 1000)
+        || left.capability.id.localeCompare(right.capability.id)
+      ));
+  }
+
+  manifests({ rendererOnly = false }: { rendererOnly?: boolean } = {}): CapabilityManifest[] {
+    return this.list().map(({ capability }) => {
+      const operations: CapabilityOperationManifest[] = Object.entries(capability.operations)
+        .filter(([, operation]) => !rendererOnly || operation.rendererSafe === true)
+        .map(([id, operation]) => ({
+          id,
+          kind: operation.kind,
+          rendererSafe: operation.rendererSafe === true,
+        }));
+      return {
+        id: capability.id,
+        kind: capability.kind,
+        name: capability.name,
+        priority: capability.priority,
+        sourceId: capability.sourceId,
+        operations,
+      };
+    });
+  }
+
+  async invoke<T = unknown>(
+    capabilityId: string,
+    operationId: string,
+    payload: unknown,
+    options: { renderer?: boolean } = {},
+  ): Promise<T> {
+    const { capability, operation } = this.resolveOperation(capabilityId, operationId, options);
+    if (!operation.handler) throw new Error(`Capability operation "${capabilityId}.${operationId}" is not invokable.`);
+    const input = (operation.input ?? recordSchema).parse(payload);
+    const result = await operation.handler(input, { capability, operationId });
+    return (operation.output ? operation.output.parse(result) : result) as T;
+  }
+
+  async subscribe<T = unknown>(
+    capabilityId: string,
+    operationId: string,
+    payload: unknown,
+    emit: (event: T) => void,
+    options: { renderer?: boolean; subscriptionId?: string } = {},
+  ): Promise<string> {
+    const { capability, operation } = this.resolveOperation(capabilityId, operationId, options);
+    if (!operation.subscribe) throw new Error(`Capability operation "${capabilityId}.${operationId}" is not subscribable.`);
+    const input = (operation.input ?? recordSchema).parse(payload);
+    const subscriptionId = options.subscriptionId ?? `${capabilityId}:${operationId}:${this.nextSubscriptionId++}`;
+    this.unsubscribe(subscriptionId);
+    const dispose = await operation.subscribe(input, emit, { capability, operationId });
+    this.subscriptions.set(subscriptionId, { capabilityId, dispose });
+    return subscriptionId;
+  }
+
+  unsubscribe(subscriptionId: string): void {
+    const entry = this.subscriptions.get(subscriptionId);
+    if (!entry) return;
+    entry.dispose();
+    this.subscriptions.delete(subscriptionId);
+  }
+
+  destroy(): void {
+    for (const subscriptionId of [...this.subscriptions.keys()]) this.unsubscribe(subscriptionId);
+    this.capabilities.clear();
+  }
+
+  private resolveOperation(capabilityId: string, operationId: string, options: { renderer?: boolean }) {
+    const entry = this.capabilities.get(capabilityId);
+    if (!entry || !this.isEnabled(entry)) throw new Error(`Capability "${capabilityId}" is not available.`);
+    const operation = entry.capability.operations[operationId];
+    if (!operation) throw new Error(`Capability operation "${capabilityId}.${operationId}" is not available.`);
+    if (options.renderer && operation.rendererSafe !== true) {
+      throw new Error(`Capability operation "${capabilityId}.${operationId}" is not available to renderers.`);
+    }
+    return { ...entry, operation };
+  }
+
+  private isEnabled(entry: RegisteredCapability): boolean {
+    if (this.options.isPluginEnabled && !this.options.isPluginEnabled(entry.pluginId)) return false;
+    if (this.options.isCapabilityEnabled && !this.options.isCapabilityEnabled(entry.capability, entry.pluginId)) return false;
+    return entry.capability.isEnabled?.() ?? true;
+  }
+}

package/src/capabilities/service-capabilities.ts

@@ -0,0 +1,27 @@
+import type { BrokerConnectionStatus } from "../types/broker";
+import type { QuoteSubscriptionTarget } from "../types/data-provider";
+import type { Quote } from "../types/financials";
+
+export const BROKER_CAPABILITY_ID = "broker.core";
+export const NOTES_FILES_CAPABILITY_ID = "notes.files";
+export const AI_RUNNER_CAPABILITY_ID = "ai.runner";
+
+export type BrokerStatusEvent = {
+  kind: "status";
+  instanceId: string;
+  status: BrokerConnectionStatus;
+};
+
+export type BrokerQuoteEvent = {
+  kind: "quote";
+  target: QuoteSubscriptionTarget;
+  quote: Quote;
+};
+
+export type BrokerRemoteEvent = BrokerStatusEvent | BrokerQuoteEvent;
+
+export type AiRunnerEvent =
+  | { kind: "chunk"; output: string }
+  | { kind: "done"; output: string }
+  | { kind: "cancelled" }
+  | { kind: "error"; error: string };

package/src/capabilities/types.ts

@@ -0,0 +1,84 @@
+import type { CachePolicyMap } from "../types/persistence";
+import type { AssetDataProvider } from "../types/data-provider";
+import type { NewsDataProvider } from "../types/capability-route-source";
+
+export type CapabilityOperationKind = "read" | "query" | "action" | "stream";
+
+export type CapabilityKind =
+  | "asset-data"
+  | "news"
+  | "plugin-service";
+
+export interface CapabilitySchema<T = unknown> {
+  parse(value: unknown): T;
+}
+
+export interface CapabilityHandlerContext {
+  capability: PluginCapability;
+  operationId: string;
+}
+
+export type CapabilityStreamEmit<T = unknown> = (event: T) => void;
+
+export interface CapabilityOperation<I = unknown, O = unknown, E = unknown> {
+  kind: CapabilityOperationKind;
+  rendererSafe?: boolean;
+  input?: CapabilitySchema<I>;
+  output?: CapabilitySchema<O>;
+  cachePolicy?: CachePolicyMap[keyof CachePolicyMap];
+  handler?: (input: I, ctx: CapabilityHandlerContext) => Promise<O> | O;
+  subscribe?: (input: I, emit: CapabilityStreamEmit<E>, ctx: CapabilityHandlerContext) => (() => void) | Promise<() => void>;
+}
+
+export interface PluginCapability {
+  readonly id: string;
+  readonly kind: CapabilityKind | string;
+  readonly name: string;
+  readonly priority?: number;
+  readonly cachePolicy?: CachePolicyMap;
+  readonly sourceId?: string;
+  readonly operations: Record<string, CapabilityOperation<any, any, any>>;
+  isEnabled?(): boolean;
+}
+
+export interface AssetDataCapability extends PluginCapability {
+  readonly kind: "asset-data";
+  readonly provider: AssetDataProvider;
+}
+
+export interface NewsCapability extends PluginCapability {
+  readonly kind: "news";
+  readonly provider: NewsDataProvider;
+}
+
+export interface CapabilityOperationManifest {
+  id: string;
+  kind: CapabilityOperationKind;
+  rendererSafe: boolean;
+}
+
+export interface CapabilityManifest {
+  id: string;
+  kind: string;
+  name: string;
+  priority?: number;
+  sourceId?: string;
+  operations: CapabilityOperationManifest[];
+}
+
+export interface CapabilityRegistryOptions {
+  isPluginEnabled?(pluginId: string): boolean;
+  isCapabilityEnabled?(capability: PluginCapability, pluginId: string): boolean;
+}
+
+export interface RegisteredCapability {
+  pluginId: string;
+  capability: PluginCapability;
+}
+
+export const recordSchema: CapabilitySchema<Record<string, unknown>> = {
+  parse(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+    return value as Record<string, unknown>;
+  },
+};

package/src/cli/commands/ticker.ts

@@ -14,7 +14,8 @@ import {
 import { exchangeShortName, marketStateLabel } from "../../utils/market-status";
 import type { AppConfig } from "../../types/config";
 import type { FinancialStatement, TickerFinancials } from "../../types/financials";
-import type { NewsItem, SecFilingItem } from "../../types/data-provider";
+import type { SecFilingItem } from "../../types/data-provider";
+import type { NewsArticle } from "../../news/types";
 import type { TickerRecord } from "../../types/ticker";
 import { createBaseConverter } from "../base-converter";
 import { initMarketData } from "../context";
@@ -187,7 +188,7 @@ export async function buildTickerReport({
   config: AppConfig;
   toBase: (value: number, fromCurrency: string) => Promise<number>;
   notes?: string;
-  recentNews?: NewsItem[];
+  recentNews?: NewsArticle[];
   recentSecFilings?: SecFilingItem[];
 }): Promise<string> {
   const quote = financials.quote;
@@ -391,7 +392,14 @@ export async function ticker(symbol: string, dependencies: TickerCommandDependen
   const notesFiles = new NotesFiles(dataDir);
   const [notesResult, newsResult, secFilingsResult] = await Promise.allSettled([
     notesFiles.load(normalized),
-    dataProvider.getNews(normalized, NEWS_ITEM_LIMIT, exchange || quote.exchangeName || ""),
+    dataProvider.getNews({
+      feed: "ticker",
+      scope: "ticker",
+      ticker: normalized,
+      exchange: exchange || quote.exchangeName || "",
+      tickerTier: "primary",
+      limit: NEWS_ITEM_LIMIT,
+    }),
     shouldFetchSecFilings(tickerFile, resolvedFinancials) && dataProvider.getSecFilings
       ? dataProvider.getSecFilings(normalized, SEC_FILING_LIMIT, exchange || quote.exchangeName || "")
       : Promise.resolve([]),

package/src/cli/context.ts

@@ -3,12 +3,11 @@ import { existsSync } from "fs";
 import { getDataDir, loadConfig } from "../data/config-store";
 import { AppPersistence } from "../data/app-persistence";
 import { TickerRepository } from "../data/ticker-repository";
-import { ProviderRouter } from "../sources/provider-router";
-import type { DataProvider } from "../types/data-provider";
+import { AssetDataRouter } from "../sources/provider-router";
+import type { PluginCapability } from "../capabilities";
 import type { AppConfig } from "../types/config";
 import type { GloomPlugin } from "../types/plugin";
 import { getLoadablePlugins } from "../plugins/catalog";
-import { createBaseConverter } from "./base-converter";
 import { fail } from "./errors";
 import type { ConfigContext, MarketContext } from "./types";
 
@@ -16,11 +15,19 @@ interface CliContextOptions {
   plugins?: GloomPlugin[];
 }
 
-function resolveCliDataProviders(config: AppConfig, plugins: GloomPlugin[]): DataProvider[] {
+function resolveCliCapabilities(config: AppConfig, plugins: GloomPlugin[]): PluginCapability[] {
   const disabledPlugins = new Set(config.disabledPlugins ?? []);
+  const disabledSources = new Set(config.disabledSources ?? []);
   return plugins
-    .filter((plugin) => !disabledPlugins.has(plugin.id) && !!plugin.dataProvider)
-    .map((plugin) => plugin.dataProvider as DataProvider);
+    .filter((plugin) => !disabledPlugins.has(plugin.id))
+    .flatMap((plugin) => (
+      (plugin.capabilities ?? [])
+        .filter((capability) => {
+          if (capability.kind !== "asset-data" && capability.kind !== "news") return false;
+          const sourceId = capability.sourceId ?? capability.id;
+          return !disabledSources.has(sourceId);
+        })
+    ));
 }
 
 export async function loadCliConfigIfAvailable(): Promise<AppConfig | null> {
@@ -46,12 +53,11 @@ export async function initConfigData(): Promise<ConfigContext> {
 export async function initMarketData(options: CliContextOptions = {}): Promise<MarketContext> {
   const context = await initConfigData();
   const plugins = options.plugins ?? getLoadablePlugins();
-  const dataProvider = new ProviderRouter(
-    null,
-    resolveCliDataProviders(context.config, plugins),
-    context.persistence.resources,
-  );
+  const capabilities = resolveCliCapabilities(context.config, plugins);
+  const dataProvider = new AssetDataRouter(null, [], context.persistence.resources);
+  dataProvider.attachRegistry({
+    brokers: new Map(),
+    getEnabledCapabilities: (kind?: string) => capabilities.filter((capability) => !kind || capability.kind === kind),
+  } as any);
   return { ...context, dataProvider };
 }
-
-export { createBaseConverter };

package/src/cli/helpers.ts

@@ -5,6 +5,7 @@ import {
   formatPercentRaw,
 } from "../utils/format";
 import { formatMarketPriceWithCurrency } from "../utils/market-format";
+
 export { slugifyName } from "../utils/slugify";
 import type { AppConfig } from "../types/config";
 import type { Watchlist, TickerRecord } from "../types/ticker";

package/src/cli/types.ts

@@ -1,7 +1,7 @@
 import type { AppConfig } from "../types/config";
 import { AppPersistence } from "../data/app-persistence";
 import { TickerRepository } from "../data/ticker-repository";
-import { ProviderRouter } from "../sources/provider-router";
+import { AssetDataRouter } from "../sources/provider-router";
 
 export type ConfigContext = {
   config: AppConfig;
@@ -11,5 +11,5 @@ export type ConfigContext = {
 };
 
 export type MarketContext = ConfigContext & {
-  dataProvider: ProviderRouter;
+  dataProvider: AssetDataRouter;
 };

package/src/components/chart/chart-controller.ts

@@ -20,7 +20,7 @@ import {
 type ViewStateWithViewport = Pick<ChartViewState, "presetRange" | "bufferRange" | "activePreset" | "resolution" | "panOffset" | "zoomLevel" | "cursorX" | "cursorY">
   | Pick<ComparisonChartViewState, "presetRange" | "bufferRange" | "activePreset" | "resolution" | "panOffset" | "zoomLevel" | "cursorX" | "cursorY">;
 
-export interface VisibleDateWindow {
+interface VisibleDateWindow {
   start: Date | null;
   end: Date | null;
   dates: Date[];
@@ -243,26 +243,6 @@ export function clampDateWindowToBounds(
   };
 }
 
-export function scaleDateWindow(
-  window: DateWindowRange | null | undefined,
-  spanScale: number,
-  anchorRatio: number,
-): DateWindowRange | null {
-  const normalizedWindow = normalizeDateWindowRange(window);
-  if (!normalizedWindow) return null;
-
-  const currentSpanMs = Math.max(normalizedWindow.endMs - normalizedWindow.startMs, 1);
-  const nextSpanMs = Math.max(currentSpanMs * spanScale, 1);
-  const ratio = clamp(anchorRatio, 0, 1);
-  const anchorMs = normalizedWindow.startMs + (currentSpanMs * ratio);
-  const nextStartMs = anchorMs - (nextSpanMs * ratio);
-
-  return {
-    start: new Date(nextStartMs),
-    end: new Date(nextStartMs + nextSpanMs),
-  };
-}
-
 export function shiftDateWindow(
   window: DateWindowRange | null | undefined,
   shiftRatio: number,
@@ -279,7 +259,7 @@ export function shiftDateWindow(
   };
 }
 
-export function getCanonicalVisiblePointCount(dates: readonly Date[], presetRange: TimeRange): number {
+function getCanonicalVisiblePointCount(dates: readonly Date[], presetRange: TimeRange): number {
   if (dates.length === 0) return 0;
   if (presetRange === "ALL") return dates.length;
   const endDate = dates[dates.length - 1]!;
@@ -419,7 +399,7 @@ export function formatVisibleSpanLabel(window: Pick<VisibleDateWindow, "start" |
   return `view:${startLabel}-${endLabel}`;
 }
 
-export function isCanonicalPresetViewport(
+function isCanonicalPresetViewport(
   dates: readonly Date[],
   state: Pick<ViewStateWithViewport, "activePreset" | "panOffset" | "zoomLevel" | "resolution">,
 ): boolean {
@@ -475,7 +455,7 @@ export function resolveVisibleActivePreset(
   return needsCanonicalPresetViewportReset(dates, state) ? state.activePreset : null;
 }
 
-export function resolvePresetSelectionWithResolution<S extends ViewStateWithViewport>(
+function resolvePresetSelectionWithResolution<S extends ViewStateWithViewport>(
   state: S,
   presetRange: TimeRange,
   resolution: ManualChartResolution,

package/src/components/chart/chart-data.ts

@@ -1,6 +1,5 @@
 import type { PricePoint } from "../../types/financials";
-import type { TimeRange, ChartRenderMode, ChartViewState, VisibleWindow } from "./chart-types";
-import { RANGE_DAYS } from "./chart-types";
+import type { ChartRenderMode, ChartViewState, VisibleWindow } from "./chart-types";
 import { getVisiblePointCount } from "./chart-viewport";
 
 export interface ProjectedChartPoint {
@@ -40,7 +39,7 @@ function coerceDate(value: Date | string | number): Date {
   return value instanceof Date ? value : new Date(value);
 }
 
-export function getRequestedRenderMode(mode?: ChartRenderMode, compact = false): ChartRenderMode {
+function getRequestedRenderMode(mode?: ChartRenderMode, compact = false): ChartRenderMode {
   if (compact) return "area";
   return mode ?? "area";
 }
@@ -77,16 +76,6 @@ export function resolveRenderMode(
   };
 }
 
-/**
- * Filter price history to the selected time range.
- */
-export function filterByTimeRange(history: PricePoint[], range: TimeRange): PricePoint[] {
-  if (range === "ALL" || history.length <= RANGE_DAYS[range]) {
-    return history;
-  }
-  return history.slice(-RANGE_DAYS[range]);
-}
-
 /**
  * Apply zoom and pan to get the visible data window.
  */
@@ -232,7 +221,7 @@ export function resolveStableOhlcProjectionOptions({
  * Downsample close-driven chart data to fit the target width.
  * Uses representative closes so line/area charts preserve the broad shape.
  */
-export function projectCloseSeries(
+function projectCloseSeries(
   points: PricePoint[],
   targetWidth: number,
 ): ProjectedChartPoint[] {

package/src/components/chart/chart-indicator-selector.tsx

@@ -1,5 +1,5 @@
-import { MultiSelectDialogButton } from "../ui";
-import { ChartControlHint } from "./chart-control-hint";
+import { MultiSelectDialogButton, ShortcutHint } from "../ui";
+import { usePaneHints } from "../layout/pane-footer";
 import {
   CHART_INDICATOR_OPTIONS,
   normalizeChartIndicatorSelection,
@@ -10,10 +10,28 @@ interface ChartIndicatorSelectorProps {
   selectedIds: ChartIndicatorId[];
   onChange: (selectedIds: ChartIndicatorId[]) => void;
   width: number;
-  variant?: "button" | "hint";
+  variant?: "button" | "hint" | "pane-hint";
   shortcutActive?: boolean;
 }
 
+function ChartIndicatorPaneHint({
+  disabled,
+  openDialog,
+}: {
+  disabled?: boolean;
+  openDialog: () => void;
+}) {
+  usePaneHints("chart-indicators", () => [{
+    id: "indicators",
+    key: "i",
+    label: "ndicators",
+    disabled,
+    onPress: openDialog,
+  }], [disabled, openDialog]);
+
+  return null;
+}
+
 export function ChartIndicatorSelector({
   selectedIds,
   onChange,
@@ -36,11 +54,15 @@ export function ChartIndicatorSelector({
       selectedValues={selectedIds}
       onChange={(values) => onChange(normalizeChartIndicatorSelection(values))}
       idPrefix="chart-indicators"
-      shortcutKey={variant === "hint" ? "i" : undefined}
+      shortcutKey={variant === "hint" || variant === "pane-hint" ? "i" : undefined}
       shortcutActive={shortcutActive}
-      renderTrigger={variant === "hint"
+      renderTrigger={variant === "pane-hint"
+        ? ({ disabled, openDialog }) => (
+          <ChartIndicatorPaneHint disabled={disabled} openDialog={openDialog} />
+        )
+        : variant === "hint"
         ? ({ disabled, openDialog }) => (
-          <ChartControlHint
+          <ShortcutHint
             hotkey="i"
             label="ndicators"
             disabled={disabled}

package/src/components/chart/chart-pane-settings.ts

@@ -1,47 +1,34 @@
-import { saveConfig } from "../../data/config-store";
 import { setPaneSettings } from "../../pane-settings";
-import { useAppState, usePaneInstance, usePaneInstanceId } from "../../state/app-context";
+import {
+  useAppDispatch,
+  useAppStateRef,
+  usePaneInstance,
+  usePaneInstanceId,
+} from "../../state/app-context";
+import { scheduleConfigSave } from "../../state/config-save-scheduler";
 import type { ChartResolution, TimeRange } from "./chart-types";
-import type { IndicatorConfig } from "./indicators/types";
 
 export function usePersistChartControlSelection(rangePresetKey: string): (
   range: TimeRange,
   resolution: ChartResolution,
 ) => void {
-  const { state, dispatch } = useAppState();
+  const dispatch = useAppDispatch();
+  const stateRef = useAppStateRef();
   const paneId = usePaneInstanceId();
   const pane = usePaneInstance();
 
   return (range, resolution) => {
-    const layout = setPaneSettings(state.config.layout, paneId, {
+    const currentState = stateRef.current;
+    const layout = setPaneSettings(currentState.config.layout, paneId, {
       ...(pane?.settings ?? {}),
       [rangePresetKey]: range,
       chartResolution: resolution,
     });
-    const layouts = state.config.layouts.map((savedLayout, index) => (
-      index === state.config.activeLayoutIndex ? { ...savedLayout, layout } : savedLayout
+    const layouts = currentState.config.layouts.map((savedLayout, index) => (
+      index === currentState.config.activeLayoutIndex ? { ...savedLayout, layout } : savedLayout
     ));
-    const nextConfig = { ...state.config, layout, layouts };
+    const nextConfig = { ...currentState.config, layout, layouts };
     dispatch({ type: "SET_CONFIG", config: nextConfig });
-    saveConfig(nextConfig).catch(() => {});
-  };
-}
-
-export function usePersistIndicatorConfig(): (config: IndicatorConfig) => void {
-  const { state, dispatch } = useAppState();
-  const paneId = usePaneInstanceId();
-  const pane = usePaneInstance();
-
-  return (indicatorConfig) => {
-    const layout = setPaneSettings(state.config.layout, paneId, {
-      ...(pane?.settings ?? {}),
-      indicators: indicatorConfig,
-    });
-    const layouts = state.config.layouts.map((savedLayout, index) => (
-      index === state.config.activeLayoutIndex ? { ...savedLayout, layout } : savedLayout
-    ));
-    const nextConfig = { ...state.config, layout, layouts };
-    dispatch({ type: "SET_CONFIG", config: nextConfig });
-    saveConfig(nextConfig).catch(() => {});
+    scheduleConfigSave(nextConfig);
   };
 }