gloomberb 0.2.0 → 0.3.1

package/src/plugins/plugin-persistence.ts

@@ -0,0 +1,85 @@
+import type { PluginStateStore } from "../data/plugin-state-store";
+import type { ResourceStore } from "../data/resource-store";
+import type { PluginPersistence } from "../types/plugin";
+
+export function createPluginPersistence(
+  pluginState: PluginStateStore,
+  resources: ResourceStore,
+  namespace: string,
+  pluginId: string,
+): PluginPersistence {
+  return {
+    getState: <T,>(key: string, options?: { schemaVersion?: number }): T | null => (
+      pluginState.get<T>(pluginId, key, options?.schemaVersion)?.value ?? null
+    ),
+    setState: (key: string, value: unknown, options?: { schemaVersion?: number }) => {
+      pluginState.set(pluginId, key, value, options?.schemaVersion);
+    },
+    deleteState: (key: string) => {
+      pluginState.delete(pluginId, key);
+    },
+    getResource: <T,>(
+      kind: string,
+      key: string,
+      options?: { sourceKey?: string; schemaVersion?: number; allowExpired?: boolean },
+    ) => {
+      const record = resources.get<T>({
+        namespace,
+        kind,
+        entityKey: key,
+        sourceKey: options?.sourceKey,
+      }, {
+        schemaVersion: options?.schemaVersion,
+        allowExpired: options?.allowExpired,
+      });
+      if (!record) return null;
+      return {
+        value: record.value,
+        fetchedAt: record.fetchedAt,
+        staleAt: record.staleAt,
+        expiresAt: record.expiresAt,
+        sourceKey: record.sourceKey,
+        schemaVersion: record.schemaVersion,
+        provenance: record.provenance,
+        stale: record.stale,
+        expired: record.expired,
+      };
+    },
+    setResource: <T,>(
+      kind: string,
+      key: string,
+      value: T,
+      options: { cachePolicy: { staleMs: number; expireMs: number }; sourceKey?: string; schemaVersion?: number; provenance?: unknown },
+    ) => {
+      const record = resources.set<T>({
+        namespace,
+        kind,
+        entityKey: key,
+        sourceKey: options.sourceKey,
+      }, value, {
+        cachePolicy: options.cachePolicy,
+        schemaVersion: options.schemaVersion,
+        provenance: options.provenance as any,
+      });
+      return {
+        value: record.value,
+        fetchedAt: record.fetchedAt,
+        staleAt: record.staleAt,
+        expiresAt: record.expiresAt,
+        sourceKey: record.sourceKey,
+        schemaVersion: record.schemaVersion,
+        provenance: record.provenance,
+        stale: record.stale,
+        expired: record.expired,
+      };
+    },
+    deleteResource: (kind: string, key: string, options?: { sourceKey?: string }) => {
+      resources.delete({
+        namespace,
+        kind,
+        entityKey: key,
+        sourceKey: options?.sourceKey,
+      });
+    },
+  };
+}

package/src/plugins/plugin-runtime.test.tsx

@@ -0,0 +1,185 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act, useEffect, useReducer } from "react";
+import { testRender } from "@opentui/react/test-utils";
+import {
+  AppContext,
+  PaneInstanceProvider,
+  appReducer,
+  createInitialState,
+} from "../state/app-context";
+import { createDefaultConfig } from "../types/config";
+import {
+  PluginRenderProvider,
+  deletePluginPaneStateValue,
+  getPluginPaneStateValue,
+  setPluginPaneStateValue,
+  type PluginRuntimeAccess,
+  usePluginConfigState,
+  usePluginPaneState,
+  usePluginState,
+} from "./plugin-runtime";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+afterEach(() => {
+  if (testSetup) {
+    testSetup.renderer.destroy();
+    testSetup = undefined;
+  }
+});
+
+describe("plugin runtime helpers", () => {
+  test("reads, writes, and deletes nested pane state under the plugin namespace", () => {
+    const initial = {
+      pluginState: {
+        news: {
+          selected: 2,
+        },
+      },
+    };
+
+    expect(getPluginPaneStateValue(initial, "news", "selected", 0)).toBe(2);
+    expect(getPluginPaneStateValue(initial, "news", "missing", 0)).toBe(0);
+    expect(setPluginPaneStateValue(initial, "news", "expanded", true)).toEqual({
+      news: {
+        selected: 2,
+        expanded: true,
+      },
+    });
+    expect(deletePluginPaneStateValue(initial, "news", "selected")).toBeUndefined();
+  });
+});
+
+describe("plugin runtime hooks", () => {
+  test("updates pane, global resume, and config state through the plugin hooks", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-plugin-runtime");
+    const stateRef: { current: ReturnType<typeof createInitialState> | null } = { current: null };
+    const dispatchRef: { current: React.Dispatch<any> | null } = { current: null };
+    const resumeState = new Map<string, unknown>();
+    const listeners = new Map<string, Set<() => void>>();
+
+    const runtime: PluginRuntimeAccess = {
+      subscribeResumeState(pluginId, key, listener) {
+        const listenerKey = `${pluginId}:${key}`;
+        if (!listeners.has(listenerKey)) listeners.set(listenerKey, new Set());
+        listeners.get(listenerKey)!.add(listener);
+        return () => {
+          const current = listeners.get(listenerKey);
+          if (!current) return;
+          current.delete(listener);
+        };
+      },
+      getResumeState(pluginId, key) {
+        return (resumeState.get(`${pluginId}:${key}`) as any) ?? null;
+      },
+      setResumeState(pluginId, key, value) {
+        const listenerKey = `${pluginId}:${key}`;
+        resumeState.set(listenerKey, value);
+        for (const listener of listeners.get(listenerKey) ?? []) listener();
+      },
+      deleteResumeState(pluginId, key) {
+        const listenerKey = `${pluginId}:${key}`;
+        resumeState.delete(listenerKey);
+        for (const listener of listeners.get(listenerKey) ?? []) listener();
+      },
+      getConfigState(pluginId, key) {
+        return (stateRef.current?.config.pluginConfig[pluginId]?.[key] as any) ?? null;
+      },
+      async setConfigState(pluginId, key, value) {
+        const currentState = stateRef.current!;
+        dispatchRef.current?.({
+          type: "SET_CONFIG",
+          config: {
+            ...currentState.config,
+            pluginConfig: {
+              ...currentState.config.pluginConfig,
+              [pluginId]: {
+                ...(currentState.config.pluginConfig[pluginId] ?? {}),
+                [key]: value,
+              },
+            },
+          },
+        });
+      },
+      async deleteConfigState(pluginId, key) {
+        const currentState = stateRef.current!;
+        const currentPluginConfig = { ...(currentState.config.pluginConfig[pluginId] ?? {}) };
+        delete currentPluginConfig[key];
+        const nextPluginConfig = { ...currentState.config.pluginConfig };
+        if (Object.keys(currentPluginConfig).length === 0) delete nextPluginConfig[pluginId];
+        else nextPluginConfig[pluginId] = currentPluginConfig;
+        dispatchRef.current?.({
+          type: "SET_CONFIG",
+          config: {
+            ...currentState.config,
+            pluginConfig: nextPluginConfig,
+          },
+        });
+      },
+      getConfigStateKeys(pluginId) {
+        return Object.keys(stateRef.current?.config.pluginConfig[pluginId] ?? {}).sort();
+      },
+    };
+
+    function HookHarness() {
+      const [state, dispatch] = useReducer(appReducer, createInitialState(config));
+      stateRef.current = state;
+      dispatchRef.current = dispatch;
+
+      return (
+        <AppContext value={{ state, dispatch }}>
+          <PaneInstanceProvider paneId="portfolio-list:main">
+            <PluginRenderProvider pluginId="news" runtime={runtime}>
+              <HookProbe />
+            </PluginRenderProvider>
+          </PaneInstanceProvider>
+        </AppContext>
+      );
+    }
+
+    function HookProbe() {
+      const [paneSelection, setPaneSelection] = usePluginPaneState<number>("selectedIdx", 0);
+      const [venueScope, setVenueScope] = usePluginPaneState<string>("venueScope", "all");
+      const [provider, setProvider] = usePluginState<string>("provider", "claude");
+      const [mode, setMode] = usePluginConfigState<string>("displayMode", "compact");
+
+      useEffect(() => {
+        if (paneSelection === 0) setPaneSelection(3);
+        if (venueScope === "all") setVenueScope("kalshi");
+        if (provider === "claude") setProvider("codex");
+        if (mode === "compact") setMode("expanded");
+      }, [
+        mode,
+        paneSelection,
+        provider,
+        setMode,
+        setPaneSelection,
+        setProvider,
+        setVenueScope,
+        venueScope,
+      ]);
+
+      return <text>{`${paneSelection}|${venueScope}|${provider}|${mode}`}</text>;
+    }
+
+    testSetup = await testRender(<HookHarness />, { width: 40, height: 5 });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("3|kalshi|codex|expanded");
+    expect(stateRef.current?.paneState["portfolio-list:main"]?.pluginState).toEqual({
+      news: {
+        selectedIdx: 3,
+        venueScope: "kalshi",
+      },
+    });
+    expect(stateRef.current?.config.pluginConfig.news).toEqual({
+      displayMode: "expanded",
+    });
+    expect(resumeState.get("news:provider")).toBe("codex");
+  });
+});

package/src/plugins/plugin-runtime.tsx

@@ -0,0 +1,175 @@
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useSyncExternalStore,
+  type ReactNode,
+  type SetStateAction,
+} from "react";
+import { useAppState, usePaneInstanceId, type PaneRuntimeState } from "../state/app-context";
+
+export interface PluginRuntimeAccess {
+  subscribeResumeState(pluginId: string, key: string, listener: () => void): () => void;
+  getResumeState<T = unknown>(pluginId: string, key: string, schemaVersion?: number): T | null;
+  setResumeState(pluginId: string, key: string, value: unknown, schemaVersion?: number): void;
+  deleteResumeState(pluginId: string, key: string): void;
+  getConfigState<T = unknown>(pluginId: string, key: string): T | null;
+  setConfigState(pluginId: string, key: string, value: unknown): Promise<void>;
+  deleteConfigState(pluginId: string, key: string): Promise<void>;
+  getConfigStateKeys(pluginId: string): string[];
+}
+
+interface PluginRenderContextValue {
+  pluginId: string;
+  runtime: PluginRuntimeAccess;
+}
+
+const PluginRenderContext = createContext<PluginRenderContextValue | null>(null);
+
+export function PluginRenderProvider({
+  pluginId,
+  runtime,
+  children,
+}: {
+  pluginId: string;
+  runtime: PluginRuntimeAccess;
+  children: ReactNode;
+}) {
+  return (
+    <PluginRenderContext value={{ pluginId, runtime }}>
+      {children}
+    </PluginRenderContext>
+  );
+}
+
+function usePluginRenderContext(): PluginRenderContextValue {
+  const context = useContext(PluginRenderContext);
+  if (!context) {
+    throw new Error("Plugin runtime hooks must be used inside a plugin render context");
+  }
+  return context;
+}
+
+export function getPluginPaneStateValue<T>(
+  paneState: PaneRuntimeState | undefined,
+  pluginId: string,
+  key: string,
+  fallback: T,
+): T {
+  return (paneState?.pluginState?.[pluginId]?.[key] as T | undefined) ?? fallback;
+}
+
+export function setPluginPaneStateValue(
+  paneState: PaneRuntimeState | undefined,
+  pluginId: string,
+  key: string,
+  value: unknown,
+): Record<string, Record<string, unknown>> {
+  return {
+    ...(paneState?.pluginState ?? {}),
+    [pluginId]: {
+      ...(paneState?.pluginState?.[pluginId] ?? {}),
+      [key]: value,
+    },
+  };
+}
+
+export function deletePluginPaneStateValue(
+  paneState: PaneRuntimeState | undefined,
+  pluginId: string,
+  key: string,
+): Record<string, Record<string, unknown>> | undefined {
+  const pluginState = paneState?.pluginState?.[pluginId];
+  if (!pluginState || !(key in pluginState)) {
+    return paneState?.pluginState;
+  }
+
+  const nextPluginState = { ...pluginState };
+  delete nextPluginState[key];
+
+  const nextAllPluginState = { ...(paneState?.pluginState ?? {}) };
+  if (Object.keys(nextPluginState).length === 0) {
+    delete nextAllPluginState[pluginId];
+  } else {
+    nextAllPluginState[pluginId] = nextPluginState;
+  }
+
+  return Object.keys(nextAllPluginState).length > 0 ? nextAllPluginState : undefined;
+}
+
+export function usePluginPaneState<T>(key: string, fallback: T, paneId?: string): [T, (value: SetStateAction<T>) => void] {
+  const { pluginId } = usePluginRenderContext();
+  const scopedPaneId = paneId ?? usePaneInstanceId();
+  const { state, dispatch } = useAppState();
+  const paneState = state.paneState[scopedPaneId];
+  const value = getPluginPaneStateValue(paneState, pluginId, key, fallback);
+
+  const setValue = useCallback((nextValue: SetStateAction<T>) => {
+    const currentPaneState = state.paneState[scopedPaneId];
+    const currentValue = getPluginPaneStateValue(currentPaneState, pluginId, key, fallback);
+    const resolved = typeof nextValue === "function"
+      ? (nextValue as (previousValue: T) => T)(currentValue)
+      : nextValue;
+
+    if (Object.is(resolved, currentValue)) {
+      return;
+    }
+
+    dispatch({
+      type: "UPDATE_PLUGIN_PANE_STATE",
+      paneId: scopedPaneId,
+      pluginId,
+      key,
+      value: resolved,
+    });
+  }, [dispatch, fallback, key, pluginId, scopedPaneId, state.paneState]);
+
+  return [value, setValue];
+}
+
+export function usePluginState<T>(key: string, fallback: T, options?: { schemaVersion?: number }): [T, (value: SetStateAction<T>) => void] {
+  const { pluginId, runtime } = usePluginRenderContext();
+  const schemaVersion = options?.schemaVersion;
+
+  const subscribe = useCallback((listener: () => void) => (
+    runtime.subscribeResumeState(pluginId, key, listener)
+  ), [key, pluginId, runtime]);
+
+  const getSnapshot = useCallback(() => (
+    runtime.getResumeState<T>(pluginId, key, schemaVersion) ?? fallback
+  ), [fallback, key, pluginId, runtime, schemaVersion]);
+
+  const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+
+  const setValue = useCallback((nextValue: SetStateAction<T>) => {
+    const currentValue = runtime.getResumeState<T>(pluginId, key, schemaVersion) ?? fallback;
+    const resolved = typeof nextValue === "function"
+      ? (nextValue as (previousValue: T) => T)(currentValue)
+      : nextValue;
+    if (Object.is(resolved, currentValue)) {
+      return;
+    }
+    runtime.setResumeState(pluginId, key, resolved, schemaVersion);
+  }, [fallback, key, pluginId, runtime, schemaVersion]);
+
+  return [value, setValue];
+}
+
+export function usePluginConfigState<T>(key: string, fallback: T): [T, (value: SetStateAction<T>) => void] {
+  const { pluginId, runtime } = usePluginRenderContext();
+  const { state } = useAppState();
+  const value = (state.config.pluginConfig[pluginId]?.[key] as T | undefined) ?? fallback;
+
+  const setValue = useCallback((nextValue: SetStateAction<T>) => {
+    const currentValue = (state.config.pluginConfig[pluginId]?.[key] as T | undefined) ?? fallback;
+    const resolved = typeof nextValue === "function"
+      ? (nextValue as (previousValue: T) => T)(currentValue)
+      : nextValue;
+    if (Object.is(resolved, currentValue)) {
+      return;
+    }
+    void runtime.setConfigState(pluginId, key, resolved);
+  }, [fallback, key, pluginId, runtime, state.config.pluginConfig]);
+
+  return [value, setValue];
+}

package/src/plugins/prediction-markets/cache.ts

@@ -0,0 +1,114 @@
+import type {
+  PredictionCategoryId,
+  PredictionHistoryRange,
+  PredictionMarketDetail,
+  PredictionMarketSummary,
+  PredictionVenue,
+} from "./types";
+
+export function buildPredictionCatalogCacheKey(
+  venue: PredictionVenue,
+  categoryId: PredictionCategoryId,
+  searchQuery: string,
+): string {
+  return `${venue}|${categoryId}|${searchQuery.trim().toLowerCase()}`;
+}
+
+export function buildPredictionCatalogResourceKey(
+  venue: PredictionVenue,
+  categoryId: PredictionCategoryId,
+  searchQuery: string,
+): string {
+  return `${venue}:${categoryId}:${searchQuery.trim().toLowerCase() || "all"}`;
+}
+
+export function buildPredictionDetailCacheKey(
+  marketKey: string,
+  historyRange: PredictionHistoryRange,
+): string {
+  return `${marketKey}|${historyRange}`;
+}
+
+export function buildPredictionDetailResourceKey(
+  marketKey: string,
+  historyRange: PredictionHistoryRange,
+): string {
+  return `${marketKey}:${historyRange}`;
+}
+
+export function updatePredictionCatalogCacheEntries(
+  current: Record<string, PredictionMarketSummary[]>,
+  marketKey: string,
+  updater: (summary: PredictionMarketSummary) => PredictionMarketSummary,
+): Record<string, PredictionMarketSummary[]> {
+  let changed = false;
+  const next: Record<string, PredictionMarketSummary[]> = {};
+
+  for (const [cacheKey, markets] of Object.entries(current)) {
+    let cacheChanged = false;
+    next[cacheKey] = markets.map((market) => {
+      if (market.key !== marketKey) return market;
+      cacheChanged = true;
+      return updater(market);
+    });
+    changed = changed || cacheChanged;
+  }
+
+  return changed ? next : current;
+}
+
+export function updatePredictionDetailCacheEntries(
+  current: Record<string, PredictionMarketDetail>,
+  marketKey: string,
+  updater: (detail: PredictionMarketDetail) => PredictionMarketDetail,
+): Record<string, PredictionMarketDetail> {
+  let changed = false;
+  const next: Record<string, PredictionMarketDetail> = {};
+  const prefix = `${marketKey}|`;
+
+  for (const [cacheKey, detail] of Object.entries(current)) {
+    if (!cacheKey.startsWith(prefix)) {
+      next[cacheKey] = detail;
+      continue;
+    }
+    changed = true;
+    next[cacheKey] = updater(detail);
+  }
+
+  return changed ? next : current;
+}
+
+export function updatePredictionPendingCounts(
+  current: Record<string, number>,
+  key: string,
+  delta: number,
+): Record<string, number> {
+  const nextValue = Math.max(0, (current[key] ?? 0) + delta);
+  if ((current[key] ?? 0) === nextValue) {
+    return current;
+  }
+
+  if (nextValue === 0) {
+    if (!(key in current)) return current;
+    const next = { ...current };
+    delete next[key];
+    return next;
+  }
+
+  return {
+    ...current,
+    [key]: nextValue,
+  };
+}
+
+export function updatePredictionErrorState(
+  current: Record<string, string | null>,
+  key: string,
+  value: string | null,
+): Record<string, string | null> {
+  if ((current[key] ?? null) === value) return current;
+  return {
+    ...current,
+    [key]: value,
+  };
+}