gloomberb 0.2.0 → 0.3.1

package/src/pane-settings.ts

@@ -0,0 +1,73 @@
+import {
+  cloneLayout,
+  clonePaneSettings,
+  findPaneInstance,
+  type LayoutConfig,
+  type PaneInstanceConfig,
+} from "./types/config";
+
+export function getPaneSettings(instance: PaneInstanceConfig | null | undefined): Record<string, unknown> {
+  return clonePaneSettings(instance?.settings) ?? {};
+}
+
+export function getPaneSettingValue<T>(
+  instance: PaneInstanceConfig | null | undefined,
+  key: string,
+  fallback: T,
+): T {
+  return (instance?.settings?.[key] as T | undefined) ?? fallback;
+}
+
+export function updatePaneInstance(
+  layout: LayoutConfig,
+  paneId: string,
+  updater: (instance: PaneInstanceConfig) => PaneInstanceConfig,
+): LayoutConfig {
+  const existing = findPaneInstance(layout, paneId);
+  if (!existing) return layout;
+
+  const nextLayout = cloneLayout(layout);
+  const index = nextLayout.instances.findIndex((instance) => instance.instanceId === paneId);
+  if (index < 0) return layout;
+
+  nextLayout.instances[index] = updater(nextLayout.instances[index]!);
+  return nextLayout;
+}
+
+export function setPaneSettings(
+  layout: LayoutConfig,
+  paneId: string,
+  settings: Record<string, unknown> | undefined,
+): LayoutConfig {
+  return updatePaneInstance(layout, paneId, (instance) => ({
+    ...instance,
+    settings: clonePaneSettings(settings),
+  }));
+}
+
+export function setPaneSetting(
+  layout: LayoutConfig,
+  paneId: string,
+  key: string,
+  value: unknown,
+): LayoutConfig {
+  const current = findPaneInstance(layout, paneId);
+  if (!current) return layout;
+  return setPaneSettings(layout, paneId, {
+    ...(current.settings ?? {}),
+    [key]: value,
+  });
+}
+
+export function deletePaneSetting(
+  layout: LayoutConfig,
+  paneId: string,
+  key: string,
+): LayoutConfig {
+  const current = findPaneInstance(layout, paneId);
+  if (!current?.settings || !(key in current.settings)) return layout;
+
+  const nextSettings = { ...current.settings };
+  delete nextSettings[key];
+  return setPaneSettings(layout, paneId, Object.keys(nextSettings).length > 0 ? nextSettings : undefined);
+}

package/src/plugins/builtin/ai/ask-ai-detail-tab.tsx

@@ -0,0 +1,338 @@
+import { useRef, useEffect, useState, useCallback } from "react";
+import { useKeyboard } from "@opentui/react";
+import { TextAttributes } from "@opentui/core";
+import type { InputRenderable } from "@opentui/core";
+import type { DetailTabProps } from "../../../types/plugin";
+import { useAppState, usePaneTicker } from "../../../state/app-context";
+import { useFxRatesMap } from "../../../market-data/hooks";
+import { usePluginState } from "../../../plugins/plugin-runtime";
+import { useInlineTickers } from "../../../state/use-inline-tickers";
+import { TickerBadgeText } from "../../../components/ticker-badge-text";
+import { colors } from "../../../theme/colors";
+import { Spinner } from "../../../components/spinner";
+import { buildTickerAiContext } from "./ticker-context";
+import { detectProviders, getAvailableProviders, resolveDefaultAiProviderId, __setDetectedProvidersForTests, type AiProvider } from "./providers";
+import { runAiPrompt } from "./runner";
+import { truncateWithEllipsis } from "./utils";
+
+interface ChatMessage {
+  role: "user" | "assistant";
+  content: string;
+  loading?: boolean;
+}
+
+interface PersistedConversation {
+  updatedAt: number;
+  messages: ChatMessage[];
+}
+
+const ASK_AI_HISTORY_LIMIT = 40;
+const ASK_AI_RETENTION_MS = 90 * 24 * 60 * 60_000;
+const chatHistories = new Map<string, ChatMessage[]>();
+
+export { __setDetectedProvidersForTests };
+export type { AiProvider };
+
+export function __setAskAiHistoryForTests(symbol: string, messages: ChatMessage[]): void {
+  chatHistories.set(symbol, messages);
+}
+
+export function __resetAskAiHistoryForTests(): void {
+  chatHistories.clear();
+}
+
+function getProviderHeaderParts(providerName: string, canSwitch: boolean, width: number): { prefix: string; label: string } {
+  if (width <= 0) return { prefix: "", label: "" };
+
+  const variants = [
+    { prefix: "Provider: ", label: canSwitch ? `${providerName} (t to switch)` : providerName },
+    { prefix: "Provider: ", label: canSwitch ? `${providerName} (t)` : providerName },
+    { prefix: "", label: canSwitch ? `${providerName} (t to switch)` : providerName },
+    { prefix: "", label: canSwitch ? `${providerName} (t)` : providerName },
+    { prefix: "", label: providerName },
+  ];
+
+  for (const variant of variants) {
+    if (variant.prefix.length + variant.label.length <= width) {
+      return variant;
+    }
+  }
+
+  return { prefix: "", label: truncateWithEllipsis(providerName, width) };
+}
+
+export function AskAiDetailTab({ width, height, focused, onCapture }: DetailTabProps) {
+  const { state } = useAppState();
+  const { ticker, financials } = usePaneTicker();
+  const exchangeRates = useFxRatesMap([
+    state.config.baseCurrency,
+    ticker?.metadata.currency,
+    financials?.quote?.currency,
+    ...(ticker?.metadata.positions.map((position) => position.currency) ?? []),
+  ]);
+  const effectiveExchangeRates = exchangeRates.size > 1 || state.exchangeRates.size === 0
+    ? exchangeRates
+    : state.exchangeRates;
+  const [providers] = useState(() => detectProviders());
+  const defaultProviderId = resolveDefaultAiProviderId(providers);
+  const [providerId, setProviderId] = usePluginState<string>("providerId", defaultProviderId);
+  const [messages, setMessages] = useState<ChatMessage[]>([]);
+  const [inputFocused, setInputFocused] = useState(false);
+  const [inputValue, setInputValue] = useState("");
+  const inputRef = useRef<InputRenderable>(null);
+  const runRef = useRef<ReturnType<typeof runAiPrompt> | null>(null);
+  const availableProviders = getAvailableProviders(providers);
+  const currentProvider = providers.find((provider) => provider.id === providerId && provider.available)
+    ?? providers.find((provider) => provider.id === defaultProviderId)
+    ?? providers[0];
+
+  const tickerSymbol = ticker?.metadata.ticker ?? null;
+  const conversationKey = tickerSymbol && currentProvider
+    ? `conversation:${currentProvider.id}:${tickerSymbol}`
+    : "__conversation:none__";
+  const [persistedConversation, setPersistedConversation] = usePluginState<PersistedConversation | null>(
+    conversationKey,
+    null,
+    { schemaVersion: 1 },
+  );
+
+  useEffect(() => {
+    if (!tickerSymbol) {
+      setMessages((previous) => (previous.length === 0 ? previous : []));
+      return;
+    }
+
+    if (persistedConversation && Date.now() - persistedConversation.updatedAt <= ASK_AI_RETENTION_MS) {
+      chatHistories.set(tickerSymbol, persistedConversation.messages);
+    }
+
+    const nextMessages = chatHistories.get(tickerSymbol) ?? [];
+    setMessages((previous) => (
+      previous.length === nextMessages.length && previous.every((message, index) => message === nextMessages[index])
+        ? previous
+        : nextMessages
+    ));
+  }, [persistedConversation, tickerSymbol]);
+
+  useEffect(() => {
+    if (!tickerSymbol || !currentProvider || messages.length === 0) return;
+    const trimmed = messages.filter((message) => !message.loading).slice(-ASK_AI_HISTORY_LIMIT);
+    chatHistories.set(tickerSymbol, trimmed);
+    setPersistedConversation({
+      updatedAt: Date.now(),
+      messages: trimmed,
+    });
+  }, [currentProvider, messages, setPersistedConversation, tickerSymbol]);
+
+  const cycleProvider = useCallback(() => {
+    if (availableProviders.length <= 1) return;
+    setProviderId((current) => {
+      const currentIndex = providers.findIndex((provider) => provider.id === current);
+      let nextIndex = currentIndex >= 0 ? (currentIndex + 1) % providers.length : 0;
+      while (!providers[nextIndex]?.available) {
+        nextIndex = (nextIndex + 1) % providers.length;
+      }
+      return providers[nextIndex]?.id ?? current;
+    });
+  }, [availableProviders.length, providers, setProviderId]);
+
+  const focusInput = useCallback(() => {
+    setInputFocused(true);
+    onCapture(true);
+    inputRef.current?.focus();
+  }, [onCapture]);
+
+  const blurInput = useCallback(() => {
+    setInputFocused(false);
+    onCapture(false);
+  }, [onCapture]);
+
+  const sendMessage = useCallback(async (text: string) => {
+    if (!ticker || !currentProvider?.available || runRef.current) return;
+
+    const userMessage: ChatMessage = { role: "user", content: text };
+    const assistantMessage: ChatMessage = { role: "assistant", content: "", loading: true };
+
+    setMessages((previous) => [...previous, userMessage, assistantMessage]);
+
+    const context = buildTickerAiContext(
+      ticker,
+      financials,
+      state.config.baseCurrency,
+      effectiveExchangeRates,
+    );
+    const fullPrompt = `You are a financial analyst assistant. Here is the current financial data for the company being discussed:\n\n${context}\n\nUser question: ${text}`;
+
+    try {
+      const run = runAiPrompt({
+        provider: currentProvider,
+        prompt: fullPrompt,
+        onChunk: (output) => {
+          setMessages((previous) => {
+            const updated = [...previous];
+            updated[updated.length - 1] = { role: "assistant", content: output, loading: true };
+            return updated;
+          });
+        },
+      });
+      runRef.current = run;
+      const output = await run.done;
+      setMessages((previous) => {
+        const updated = [...previous];
+        updated[updated.length - 1] = {
+          role: "assistant",
+          content: output,
+          loading: false,
+        };
+        return updated;
+      });
+    } catch (error: any) {
+      setMessages((previous) => {
+        const updated = [...previous];
+        updated[updated.length - 1] = {
+          role: "assistant",
+          content: `Error: ${error?.message || "Failed to run AI command"}`,
+          loading: false,
+        };
+        return updated;
+      });
+    } finally {
+      runRef.current = null;
+    }
+  }, [currentProvider, effectiveExchangeRates, financials, state.config.baseCurrency, ticker]);
+
+  useKeyboard((event) => {
+    if (!focused) return;
+
+    const isEnter = event.name === "enter" || event.name === "return";
+    if (!inputFocused) {
+      if (isEnter) {
+        focusInput();
+        return;
+      }
+      if (event.name === "t" || event.name === "T") {
+        cycleProvider();
+      }
+      return;
+    }
+
+    if (event.name === "escape") {
+      blurInput();
+    }
+  });
+
+  useEffect(() => () => {
+    runRef.current?.cancel();
+  }, []);
+
+  const { catalog, openTicker } = useInlineTickers(messages.map((message) => message.content));
+
+  if (!ticker) return <text fg={colors.textDim}>Select a ticker to ask AI.</text>;
+
+  if (availableProviders.length === 0) {
+    return (
+      <box flexDirection="column" padding={1} flexGrow={1}>
+        <box height={1}>
+          <text attributes={TextAttributes.BOLD} fg={colors.textBright}>Ask AI</text>
+        </box>
+        <box height={1} />
+        <text fg={colors.textDim}>No AI CLI tools detected. Install one of:</text>
+        <box height={1} />
+        <text fg={colors.text}>  claude  - Claude Code (claude.ai/claude-code)</text>
+        <text fg={colors.text}>  gemini  - Gemini CLI (github.com/google-gemini/gemini-cli)</text>
+        <text fg={colors.text}>  codex   - OpenAI Codex (github.com/openai/codex)</text>
+      </box>
+    );
+  }
+
+  const contentWidth = Math.max(width - 2, 0);
+  const dividerWidth = Math.max(contentWidth, 0);
+  const chatHeight = Math.max(height - 7, 4);
+  const providerHeader = getProviderHeaderParts(
+    currentProvider?.name || "None",
+    availableProviders.length > 1,
+    Math.max(contentWidth - "Ask AI".length - 1, 0),
+  );
+
+  return (
+    <box flexDirection="column" paddingX={1} paddingTop={1} height={height - 2}>
+      <box flexDirection="row" height={1}>
+        <text attributes={TextAttributes.BOLD} fg={colors.textBright}>Ask AI</text>
+        <box flexGrow={1} />
+        <box onMouseDown={cycleProvider}>
+          <text fg={colors.textMuted}>
+            {providerHeader.prefix}
+            <span fg={colors.textBright}>{providerHeader.label}</span>
+          </text>
+        </box>
+      </box>
+
+      <scrollbox height={chatHeight} scrollY>
+        <box flexDirection="column">
+          {messages.length === 0 ? (
+            <box paddingTop={1}>
+              <text fg={colors.textDim}>
+                Ask questions about {ticker.metadata.ticker}. Financial data will be included as context.
+              </text>
+            </box>
+          ) : (
+            messages.map((message, index) => (
+              <box key={index} flexDirection="column" paddingTop={index > 0 ? 1 : 0}>
+                <box height={1}>
+                  <text
+                    attributes={TextAttributes.BOLD}
+                    fg={message.role === "user" ? colors.textBright : colors.positive}
+                  >
+                    {message.role === "user" ? "You" : currentProvider?.name || "AI"}
+                    {message.loading ? " (thinking...)" : ""}
+                  </text>
+                </box>
+                <box>
+                  {message.content ? (
+                    <TickerBadgeText
+                      text={message.content}
+                      lineWidth={contentWidth}
+                      catalog={catalog}
+                      textColor={colors.text}
+                      openTicker={openTicker}
+                    />
+                  ) : message.loading ? (
+                    <Spinner label="Generating..." />
+                  ) : (
+                    <text fg={colors.text}>{""}</text>
+                  )}
+                </box>
+              </box>
+            ))
+          )}
+        </box>
+      </scrollbox>
+
+      <box height={1}>
+        <text fg={colors.textDim}>{"\u2500".repeat(dividerWidth)}</text>
+      </box>
+
+      <box flexDirection="row" height={1} onMouseDown={focusInput}>
+        <text fg={colors.textMuted}>{"> "}</text>
+        <box flexGrow={1}>
+          <input
+            ref={inputRef}
+            placeholder={inputFocused ? "Ask a question..." : "Enter to start typing"}
+            focused={inputFocused && focused}
+            textColor={colors.text}
+            placeholderColor={colors.textDim}
+            backgroundColor={inputFocused && focused ? colors.panel : colors.bg}
+            onInput={(value) => setInputValue(value)}
+            onChange={(value) => setInputValue(value)}
+            onSubmit={() => {
+              if (!inputValue.trim()) return;
+              void sendMessage(inputValue.trim());
+              setInputValue("");
+              (inputRef.current as any)?.editBuffer?.setText?.("");
+            }}
+          />
+        </box>
+      </box>
+    </box>
+  );
+}

package/src/plugins/builtin/ai/gloomberb-cli.ts

@@ -0,0 +1,70 @@
+import { existsSync } from "fs";
+import { resolve } from "path";
+import { execSync } from "child_process";
+
+export interface GloomberbCliCommand {
+  argv: string[];
+  display: string;
+  mode: "installed" | "bun-source" | "unavailable";
+}
+
+function commandExists(command: string): boolean {
+  try {
+    if (typeof Bun !== "undefined" && typeof Bun.which === "function") {
+      return !!Bun.which(command);
+    }
+  } catch {
+    // Fall back to shell lookup when Bun.which is unavailable.
+  }
+
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function resolveGloomberbCliCommand({
+  cwd = process.cwd(),
+  hasCommand = commandExists,
+  fileExists = existsSync,
+}: {
+  cwd?: string;
+  hasCommand?: (command: string) => boolean;
+  fileExists?: (path: string) => boolean;
+} = {}): GloomberbCliCommand {
+  if (hasCommand("gloomberb")) {
+    return {
+      argv: ["gloomberb"],
+      display: "gloomberb",
+      mode: "installed",
+    };
+  }
+
+  const sourceEntry = resolve(cwd, "src", "index.tsx");
+  if (fileExists(sourceEntry)) {
+    return {
+      argv: ["bun", sourceEntry],
+      display: `bun ${sourceEntry}`,
+      mode: "bun-source",
+    };
+  }
+
+  return {
+    argv: [],
+    display: "gloomberb",
+    mode: "unavailable",
+  };
+}
+
+export function buildGloomberbCliInstructions(command = resolveGloomberbCliCommand()): string[] {
+  const base = command.display;
+  return [
+    `The local Gloomberb CLI is available as: ${base}`,
+    `Useful commands: ${base} help`,
+    `Inspect a ticker with: ${base} ticker <symbol>`,
+    `Inspect a portfolio or watchlist with: ${base} portfolio [name]`,
+    "The CLI does not search for unknown companies, so use it to validate ticker candidates before returning them.",
+  ];
+}

package/src/plugins/builtin/ai/index.test.tsx

@@ -0,0 +1,139 @@
+import { describe, expect, test } from "bun:test";
+import { createDefaultConfig } from "../../../types/config";
+import type { GloomPluginContext, PaneDef, PaneTemplateDef, DetailTabDef } from "../../../types/plugin";
+import { aiPlugin } from "./index";
+import { __setDetectedProvidersForTests, type AiProvider } from "./providers";
+
+function createPluginContext() {
+  const panes: PaneDef[] = [];
+  const templates: PaneTemplateDef[] = [];
+  const detailTabs: DetailTabDef[] = [];
+
+  const ctx = {
+    registerPane: (pane: PaneDef) => { panes.push(pane); },
+    registerPaneTemplate: (template: PaneTemplateDef) => { templates.push(template); },
+    registerCommand: () => {},
+    registerColumn: () => {},
+    registerBroker: () => {},
+    registerDataProvider: () => {},
+    registerDetailTab: (tab: DetailTabDef) => { detailTabs.push(tab); },
+    registerShortcut: () => {},
+    registerTickerAction: () => {},
+    getData: () => null,
+    getTicker: () => null,
+    getConfig: () => createDefaultConfig("/tmp/gloomberb-ai-plugin"),
+    dataProvider: {} as any,
+    tickerRepository: {} as any,
+    persistence: {} as any,
+    log: { info() {}, warn() {}, error() {}, debug() {} },
+    resume: {
+      getState: () => null,
+      setState: () => {},
+      deleteState: () => {},
+      getPaneState: () => null,
+      setPaneState: () => {},
+      deletePaneState: () => {},
+    },
+    configState: {
+      get: () => null,
+      set: async () => {},
+      delete: async () => {},
+      keys: () => [],
+    },
+    paneSettings: {
+      get: () => null,
+      set: async () => {},
+      delete: async () => {},
+    },
+    createBrokerInstance: async () => { throw new Error("unused"); },
+    updateBrokerInstance: async () => {},
+    syncBrokerInstance: async () => {},
+    removeBrokerInstance: async () => {},
+    selectTicker: () => {},
+    switchPanel: () => {},
+    switchTab: () => {},
+    openCommandBar: () => {},
+    showPane: () => {},
+    createPaneFromTemplate: () => {},
+    hidePane: () => {},
+    focusPane: () => {},
+    pinTicker: () => {},
+    openPaneSettings: () => {},
+    on: () => () => {},
+    emit: () => {},
+    showWidget: () => {},
+    hideWidget: () => {},
+    showToast: () => {},
+  } satisfies GloomPluginContext;
+
+  return { ctx, panes, templates, detailTabs };
+}
+
+describe("aiPlugin", () => {
+  test("registers the Ask AI detail tab and AI screener pane template", async () => {
+    const providers: AiProvider[] = [
+      { id: "claude", name: "Claude", command: "claude", available: true, buildArgs: () => [] },
+      { id: "gemini", name: "Gemini", command: "gemini", available: false, buildArgs: () => [] },
+    ];
+    __setDetectedProvidersForTests(providers);
+
+    const { ctx, panes, templates, detailTabs } = createPluginContext();
+    await aiPlugin.setup?.(ctx);
+
+    const detailTab = detailTabs.find((entry) => entry.id === "ai-chat");
+    const pane = panes.find((entry) => entry.id === "ai-screener");
+    const template = templates.find((entry) => entry.id === "new-ai-screener-pane");
+
+    expect(detailTab?.name).toBe("Ask AI");
+    expect(pane?.name).toBe("AI Screener");
+    expect(pane?.settings?.({
+      config: createDefaultConfig("/tmp/gloomberb-ai-plugin"),
+      layout: createDefaultConfig("/tmp/gloomberb-ai-plugin").layout,
+      paneId: "ai-screener:test",
+      paneType: "ai-screener",
+      pane: {
+        instanceId: "ai-screener:test",
+        paneId: "ai-screener",
+        settings: {},
+      },
+      settings: {},
+      paneState: {},
+      activeTicker: null,
+      activeCollectionId: null,
+    })?.fields[0]?.key).toBe("columnIds");
+    expect(template?.shortcut).toEqual({
+      prefix: "AI",
+      argPlaceholder: "prompt",
+      argKind: "text",
+    });
+    expect(template?.wizard?.map((step) => step.type)).toEqual(["select", "textarea"]);
+    expect(template?.wizard?.[0]?.defaultValue).toBe("claude");
+    expect(template?.wizard?.[0]?.options).toEqual([
+      { label: "Claude", value: "claude" },
+    ]);
+    expect(template?.createInstance?.(
+      {
+        config: createDefaultConfig("/tmp/gloomberb-ai-plugin"),
+        layout: createDefaultConfig("/tmp/gloomberb-ai-plugin").layout,
+        focusedPaneId: null,
+        activeTicker: null,
+        activeCollectionId: null,
+      },
+      {
+        values: {
+          providerId: "claude",
+          prompt: "high-ROIC compounders",
+        },
+      },
+    )).toEqual({
+      title: "AI Screener",
+      placement: "floating",
+      params: {
+        prompt: "high-ROIC compounders",
+        providerId: "claude",
+      },
+    });
+
+    __setDetectedProvidersForTests(null);
+  });
+});