gloomberb 0.2.0 → 0.3.1

package/src/plugins/builtin/news.tsx

@@ -0,0 +1,143 @@
+import { useRef, useEffect, useState } from "react";
+import { useKeyboard } from "@opentui/react";
+import type { GloomPlugin, DetailTabProps } from "../../types/plugin";
+import { usePaneTicker } from "../../state/app-context";
+import { colors } from "../../theme/colors";
+import type { NewsItem } from "../../types/data-provider";
+import { useArticleSummary, useNewsQuery, useResolvedEntryValue } from "../../market-data/hooks";
+import { instrumentFromTicker } from "../../market-data/request-types";
+import { usePluginPaneState } from "../../plugins/plugin-runtime";
+import { Spinner } from "../../components/spinner";
+import { DetailFeedView, type DetailFeedItem } from "../../components/detail-feed-view";
+
+const ARTICLE_SUMMARY_CACHE_POLICY = {
+  staleMs: 30 * 24 * 60 * 60_000,
+  expireMs: 90 * 24 * 60 * 60_000,
+};
+const NEWS_ITEM_LIMIT = 50;
+
+function getFeedItems(
+  news: NewsItem[],
+  selectedUrl: string | undefined,
+  summaryCache: Map<string, string>,
+  loadingSummary: boolean,
+): DetailFeedItem[] {
+  return news.map((item) => {
+    const preview = summaryCache.get(item.url) ?? item.summary ?? undefined;
+    const isSelected = item.url === selectedUrl;
+    return {
+      id: item.url || `${item.title}:${item.publishedAt.toISOString()}`,
+      eyebrow: item.source,
+      title: item.title,
+      timestamp: item.publishedAt,
+      preview,
+      detailTitle: item.title,
+      detailMeta: [
+        item.source,
+        `Published ${item.publishedAt.toLocaleString("en-US", {
+          month: "short",
+          day: "numeric",
+          year: "numeric",
+          hour: "numeric",
+          minute: "2-digit",
+        })}`,
+      ],
+      detailBody: isSelected
+        ? preview ?? (loadingSummary ? "Loading preview..." : "No preview available.")
+        : preview ?? "",
+      detailNote: item.url,
+    };
+  });
+}
+
+function NewsTab({ width, height, focused }: DetailTabProps) {
+  const { ticker } = usePaneTicker();
+  const selectionKey = `selectedIdx:${ticker?.metadata.ticker ?? "none"}`;
+  const [selectedIdx, setSelectedIdx] = usePluginPaneState<number>(selectionKey, 0);
+  const [hoveredIdx, setHoveredIdx] = useState<number | null>(null);
+  const [summaryCache, setSummaryCache] = useState<Map<string, string>>(new Map());
+  const summaryFetchRef = useRef(0);
+  const instrument = instrumentFromTicker(ticker, ticker?.metadata.ticker ?? null);
+  const newsEntry = useNewsQuery(instrument ? { instrument, count: NEWS_ITEM_LIMIT } : null);
+  const news = useResolvedEntryValue(newsEntry) ?? [];
+  const loading = newsEntry?.phase === "loading" || (newsEntry?.phase === "refreshing" && news.length === 0);
+  const error = newsEntry?.phase === "error" ? newsEntry.error?.message ?? "Failed to load news" : null;
+
+  useEffect(() => {
+    summaryFetchRef.current += 1;
+    setSummaryCache(new Map());
+    setHoveredIdx(null);
+  }, [ticker?.metadata.ticker]);
+
+  const selected = news[selectedIdx];
+  const cachedSelectedSummary = selected ? summaryCache.get(selected.url) : undefined;
+  const articleSummaryEntry = useArticleSummary(
+    selected && !selected.summary && !cachedSelectedSummary ? selected.url : null,
+  );
+  const selectedSummary = useResolvedEntryValue(articleSummaryEntry);
+  const loadingSummary = articleSummaryEntry?.phase === "loading" || articleSummaryEntry?.phase === "refreshing";
+
+  useEffect(() => {
+    if (!selected?.summary) return;
+    const summary = selected.summary;
+    setSummaryCache((prev) => prev.has(selected.url) ? prev : new Map(prev).set(selected.url, summary));
+  }, [selected?.summary, selected?.url]);
+
+  useEffect(() => {
+    if (!selected?.url || !selectedSummary) return;
+    setSummaryCache((prev) => new Map(prev).set(selected.url, selectedSummary));
+  }, [selected?.url, selectedSummary]);
+
+  useKeyboard((event) => {
+    if (!focused || news.length === 0) return;
+    if (event.name === "j" || event.name === "down") {
+      setSelectedIdx((index) => Math.min(index + 1, news.length - 1));
+    } else if (event.name === "k" || event.name === "up") {
+      setSelectedIdx((index) => Math.max(index - 1, 0));
+    }
+  });
+
+  useEffect(() => {
+    if (news.length > 0 && selectedIdx >= news.length) {
+      setSelectedIdx(Math.max(0, news.length - 1));
+    }
+  }, [news.length, selectedIdx, setSelectedIdx]);
+
+  if (!ticker) return <text fg={colors.textDim}>Select a ticker to view news.</text>;
+  if (loading && news.length === 0) return <Spinner label="Loading news..." />;
+  if (error) return <text fg={colors.textDim}>Error: {error}</text>;
+  if (news.length === 0) return <text fg={colors.textDim}>No news available for {ticker.metadata.ticker}.</text>;
+
+  const items = getFeedItems(news, selected?.url, summaryCache, loadingSummary);
+
+  return (
+    <DetailFeedView
+      width={width}
+      height={height}
+      items={items}
+      selectedIdx={selectedIdx}
+      hoveredIdx={hoveredIdx}
+      onSelect={setSelectedIdx}
+      onHover={setHoveredIdx}
+      listVariant="single-line"
+      splitListWidthRatio={0.36}
+    />
+  );
+}
+
+export const newsPlugin: GloomPlugin = {
+  id: "news",
+  name: "News",
+  version: "1.0.0",
+  description: "View latest news for each ticker",
+  toggleable: true,
+
+  setup(ctx) {
+    ctx.registerDetailTab({
+      id: "news",
+      name: "News",
+      order: 40,
+      component: NewsTab,
+    });
+  },
+};

package/src/plugins/builtin/notes-files.ts

@@ -0,0 +1,58 @@
+import { unlink, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+
+export interface QuickNoteEntry {
+  id: string;
+  title: string;
+}
+
+const QUICK_NOTES_INDEX = "__quick-notes-index__";
+
+export class NotesFiles {
+  constructor(private readonly dataDir: string) {}
+
+  private pathFor(symbol: string): string {
+    return join(this.dataDir, `${symbol}.md`);
+  }
+
+  async load(symbol: string): Promise<string> {
+    try {
+      return await readFile(this.pathFor(symbol), "utf-8");
+    } catch {
+      return "";
+    }
+  }
+
+  async save(symbol: string, notes: string): Promise<void> {
+    await writeFile(this.pathFor(symbol), notes || "", "utf-8");
+  }
+
+  async delete(symbol: string): Promise<void> {
+    try {
+      await unlink(this.pathFor(symbol));
+    } catch {
+      // ignore missing files
+    }
+  }
+
+  private indexPath(): string {
+    return join(this.dataDir, `${QUICK_NOTES_INDEX}.json`);
+  }
+
+  async loadQuickNotesIndex(): Promise<QuickNoteEntry[]> {
+    try {
+      const raw = await readFile(this.indexPath(), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+
+  async saveQuickNotesIndex(entries: QuickNoteEntry[]): Promise<void> {
+    await writeFile(this.indexPath(), JSON.stringify(entries), "utf-8");
+  }
+
+  quickNoteKey(id: string): string {
+    return `__note-${id}__`;
+  }
+}

package/src/plugins/builtin/notes.tsx

@@ -0,0 +1,396 @@
+import { useRef, useEffect, useState, useCallback } from "react";
+import { useKeyboard } from "@opentui/react";
+import { TextAttributes } from "@opentui/core";
+import type { TextareaRenderable, InputRenderable } from "@opentui/core";
+import type { GloomPlugin, DetailTabProps, PaneProps } from "../../types/plugin";
+import { usePaneTicker } from "../../state/app-context";
+import { colors } from "../../theme/colors";
+import { MarkdownEditor } from "../../components/markdown-editor";
+import { NotesFiles, type QuickNoteEntry } from "./notes-files";
+
+function createNotesTab(notesFiles: NotesFiles) {
+  return function NotesTab({ focused, onCapture }: DetailTabProps) {
+    const { ticker } = usePaneTicker();
+    const textareaRef = useRef<TextareaRenderable | null>(null);
+    const [notesFocused, setNotesFocused] = useState(false);
+    const [loadedNotes, setLoadedNotes] = useState("");
+
+    const setNotesFocusedAndCapture = useCallback((value: boolean) => {
+      setNotesFocused(value);
+      onCapture(value);
+    }, [onCapture]);
+
+    const saveNotesFor = useCallback((symbol: string | null, text: string) => {
+      if (!symbol) return;
+      notesFiles.save(symbol, text).catch(() => {});
+    }, [notesFiles]);
+
+    useEffect(() => {
+      const textarea = textareaRef.current;
+      if (!notesFocused && textarea && ticker?.metadata.ticker) {
+        saveNotesFor(ticker.metadata.ticker, textarea.editBuffer.getText());
+      }
+    }, [notesFocused, ticker, saveNotesFor]);
+
+    const tickerSymbol = ticker?.metadata.ticker ?? null;
+    const prevSymbolRef = useRef<string | null>(null);
+    useEffect(() => {
+      if (tickerSymbol !== prevSymbolRef.current) {
+        if (textareaRef.current && prevSymbolRef.current) {
+          saveNotesFor(prevSymbolRef.current, textareaRef.current.editBuffer.getText());
+        }
+        prevSymbolRef.current = tickerSymbol;
+
+        if (!tickerSymbol) {
+          setLoadedNotes("");
+          textareaRef.current?.setText("");
+          return;
+        }
+
+        notesFiles.load(tickerSymbol).then((nextNotes) => {
+          setLoadedNotes(nextNotes);
+          textareaRef.current?.setText(nextNotes);
+        }).catch(() => {
+          setLoadedNotes("");
+          textareaRef.current?.setText("");
+        });
+      }
+    }, [tickerSymbol, saveNotesFor, notesFiles]);
+
+    useKeyboard((event) => {
+      if (!focused) return;
+      const isEnter = event.name === "enter" || event.name === "return";
+      if (isEnter && !notesFocused) {
+        setNotesFocusedAndCapture(true);
+        return;
+      }
+      if (event.name === "escape" && notesFocused) {
+        setNotesFocusedAndCapture(false);
+        return;
+      }
+    });
+
+    if (!ticker) return <text fg={colors.textDim}>Select a ticker to view notes.</text>;
+
+    return (
+      <box flexDirection="column" padding={1} flexGrow={1}>
+        <box flexDirection="row" height={1}>
+          <text attributes={TextAttributes.BOLD} fg={colors.textBright}>Notes</text>
+          <box flexGrow={1} />
+          <text fg={colors.textMuted}>
+            {notesFocused ? "editing (Esc to stop)" : "Enter to edit"}
+          </text>
+        </box>
+        <box height={1} />
+        <box flexGrow={1} onMouseDown={() => { if (!notesFocused) setNotesFocusedAndCapture(true); }}>
+          <MarkdownEditor
+            textareaKey={tickerSymbol ?? "none"}
+            focused={notesFocused}
+            initialValue={loadedNotes}
+            placeholder="Write notes about this ticker..."
+            onRef={(ref) => { textareaRef.current = ref; }}
+          />
+        </box>
+      </box>
+    );
+  };
+}
+
+let nextNoteId = 1;
+function generateNoteId(): string {
+  return `${Date.now()}-${nextNoteId++}`;
+}
+
+function createQuickNotesPane(notesFiles: NotesFiles) {
+  return function QuickNotesPane({ focused }: PaneProps) {
+    const textareaRef = useRef<TextareaRenderable | null>(null);
+    const [editing, setEditing] = useState(false);
+    const [tabs, setTabs] = useState<QuickNoteEntry[]>([]);
+    const [activeTabId, setActiveTabId] = useState<string | null>(null);
+    const [renaming, setRenaming] = useState(false);
+    const [renameValue, setRenameValue] = useState("");
+    const renameInputRef = useRef<InputRenderable>(null);
+    const prevTabRef = useRef<string | null>(null);
+    const loadedRef = useRef(false);
+
+    // Load index on mount
+    useEffect(() => {
+      if (loadedRef.current) return;
+      loadedRef.current = true;
+      notesFiles.loadQuickNotesIndex().then((entries) => {
+        if (entries.length === 0) {
+          const id = generateNoteId();
+          const initial: QuickNoteEntry[] = [{ id, title: "New" }];
+          setTabs(initial);
+          setActiveTabId(id);
+          notesFiles.saveQuickNotesIndex(initial).catch(() => {});
+        } else {
+          setTabs(entries);
+          setActiveTabId(entries[0]!.id);
+        }
+      });
+    }, []);
+
+    // Save current tab content before switching away
+    const saveCurrentTab = useCallback(() => {
+      const tabId = prevTabRef.current;
+      if (tabId && textareaRef.current) {
+        const text = textareaRef.current.editBuffer.getText();
+        notesFiles.save(notesFiles.quickNoteKey(tabId), text).catch(() => {});
+      }
+    }, []);
+
+    // Load content when active tab changes
+    useEffect(() => {
+      if (!activeTabId) return;
+      if (prevTabRef.current && prevTabRef.current !== activeTabId) {
+        saveCurrentTab();
+      }
+      prevTabRef.current = activeTabId;
+      notesFiles.load(notesFiles.quickNoteKey(activeTabId)).then((text) => {
+        textareaRef.current?.setText(text);
+      }).catch(() => {
+        textareaRef.current?.setText("");
+      });
+    }, [activeTabId, saveCurrentTab]);
+
+    // Save on editing stop
+    useEffect(() => {
+      if (!editing) saveCurrentTab();
+    }, [editing, saveCurrentTab]);
+
+    const addTab = useCallback(() => {
+      saveCurrentTab();
+      const id = generateNoteId();
+      const entry: QuickNoteEntry = { id, title: "New" };
+      setTabs((prev) => {
+        const next = [...prev, entry];
+        notesFiles.saveQuickNotesIndex(next).catch(() => {});
+        return next;
+      });
+      setActiveTabId(id);
+      setEditing(false);
+    }, [saveCurrentTab]);
+
+    const removeTab = useCallback((id: string) => {
+      setTabs((prev) => {
+        const next = prev.filter((t) => t.id !== id);
+        if (next.length === 0) {
+          const newId = generateNoteId();
+          const fresh: QuickNoteEntry[] = [{ id: newId, title: "New" }];
+          notesFiles.saveQuickNotesIndex(fresh).catch(() => {});
+          setActiveTabId(newId);
+          prevTabRef.current = null;
+          return fresh;
+        }
+        notesFiles.saveQuickNotesIndex(next).catch(() => {});
+        if (activeTabId === id) {
+          const idx = prev.findIndex((t) => t.id === id);
+          const newActive = next[Math.min(idx, next.length - 1)]!;
+          setActiveTabId(newActive.id);
+          prevTabRef.current = null;
+        }
+        return next;
+      });
+      notesFiles.delete(notesFiles.quickNoteKey(id)).catch(() => {});
+      setEditing(false);
+    }, [activeTabId]);
+
+    const startRename = useCallback(() => {
+      const tab = tabs.find((t) => t.id === activeTabId);
+      if (!tab) return;
+      setRenameValue(tab.title);
+      setRenaming(true);
+      setEditing(false);
+    }, [tabs, activeTabId]);
+
+    const commitRename = useCallback(() => {
+      const value = renameInputRef.current?.editBuffer.getText().trim() || renameValue.trim();
+      if (!value || !activeTabId) {
+        setRenaming(false);
+        return;
+      }
+      setTabs((prev) => {
+        const next = prev.map((t) => (t.id === activeTabId ? { ...t, title: value } : t));
+        notesFiles.saveQuickNotesIndex(next).catch(() => {});
+        return next;
+      });
+      setRenaming(false);
+    }, [activeTabId, renameValue]);
+
+    useKeyboard((event) => {
+      if (!focused) return;
+
+      if (renaming) {
+        if (event.name === "enter" || event.name === "return") {
+          commitRename();
+          return;
+        }
+        if (event.name === "escape") {
+          setRenaming(false);
+          return;
+        }
+        return;
+      }
+
+      const isEnter = event.name === "enter" || event.name === "return";
+      if (isEnter && !editing) {
+        setEditing(true);
+        return;
+      }
+      if (event.name === "escape" && editing) {
+        setEditing(false);
+        return;
+      }
+      if (!editing) {
+        if (event.name === "t") {
+          addTab();
+          return;
+        }
+        if (event.name === "w" && tabs.length > 0) {
+          if (activeTabId) removeTab(activeTabId);
+          return;
+        }
+        if (event.name === "r") {
+          startRename();
+          return;
+        }
+        // Tab navigation with [ and ]
+        if ((event.name === "[" || event.name === "]") && tabs.length > 1) {
+          const idx = tabs.findIndex((t) => t.id === activeTabId);
+          if (idx < 0) return;
+          const next = event.name === "]"
+            ? (idx + 1) % tabs.length
+            : (idx - 1 + tabs.length) % tabs.length;
+          saveCurrentTab();
+          setActiveTabId(tabs[next]!.id);
+          return;
+        }
+      }
+    });
+
+    return (
+      <box flexDirection="column" flexGrow={1}>
+        {/* Tab bar */}
+        <box flexDirection="row" height={1}>
+          {tabs.map((tab) => {
+            const isActive = tab.id === activeTabId;
+            return (
+              <box key={tab.id} flexDirection="row">
+                <text
+                  fg={isActive ? colors.textBright : colors.textDim}
+                  bg={isActive ? colors.selected : undefined}
+                  attributes={isActive ? TextAttributes.BOLD : 0}
+                  onMouseDown={() => {
+                    if (tab.id !== activeTabId) {
+                      saveCurrentTab();
+                      setActiveTabId(tab.id);
+                      setEditing(false);
+                    }
+                  }}
+                  onDoubleClick={() => {
+                    setActiveTabId(tab.id);
+                    startRename();
+                  }}
+                >
+                  {` ${tab.title} `}
+                </text>
+                {isActive && tabs.length > 1 ? (
+                  <text
+                    fg={colors.textMuted}
+                    onMouseDown={() => removeTab(tab.id)}
+                  >
+                    {`x `}
+                  </text>
+                ) : <text>{` `}</text>}
+              </box>
+            );
+          })}
+          <text
+            fg={colors.textMuted}
+            onMouseDown={addTab}
+          >
+            {` + `}
+          </text>
+          <box flexGrow={1} />
+          <text fg={colors.textMuted}>
+            {renaming
+              ? "type name, Enter to confirm"
+              : editing
+                ? "editing (Esc to stop)"
+                : "Enter edit | t new | w close | r rename"}
+          </text>
+        </box>
+        {/* Rename input */}
+        {renaming && (
+          <box height={1} flexDirection="row" paddingLeft={1}>
+            <text fg={colors.textDim}>{"Rename: "}</text>
+            <input
+              ref={renameInputRef}
+              initialValue={renameValue}
+              focused={renaming}
+              textColor={colors.text}
+              backgroundColor={colors.panel}
+              flexGrow={1}
+              onChange={(val: string) => setRenameValue(val)}
+            />
+          </box>
+        )}
+        {/* Editor */}
+        <box flexGrow={1} padding={1} onMouseDown={() => { if (!editing && !renaming) setEditing(true); }}>
+          <MarkdownEditor
+            textareaKey={activeTabId ?? "none"}
+            focused={editing && !renaming}
+            placeholder="Write notes..."
+            onRef={(ref) => { textareaRef.current = ref; }}
+          />
+        </box>
+      </box>
+    );
+  };
+}
+
+export const notesPlugin: GloomPlugin = {
+  id: "notes",
+  name: "Notes",
+  version: "1.0.0",
+  description: "Add markdown notes to your tickers.",
+  toggleable: true,
+
+  setup(ctx) {
+    const notesFiles = new NotesFiles(ctx.getConfig().dataDir);
+    const NotesTab = createNotesTab(notesFiles);
+    const QuickNotesPane = createQuickNotesPane(notesFiles);
+
+    ctx.on("ticker:removed", ({ symbol }) => {
+      notesFiles.delete(symbol).catch(() => {});
+    });
+
+    ctx.registerDetailTab({
+      id: "notes",
+      name: "Notes",
+      order: 50,
+      component: NotesTab,
+    });
+
+    ctx.registerPane({
+      id: "quick-notes",
+      name: "Quick Notes",
+      icon: "N",
+      component: QuickNotesPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 60, height: 20 },
+    });
+
+    ctx.registerPaneTemplate({
+      id: "new-quick-notes-pane",
+      paneId: "quick-notes",
+      label: "Quick Notes",
+      description: "Open a general-purpose notes scratchpad",
+      keywords: ["notes", "quick", "scratchpad", "memo"],
+      shortcut: { prefix: "NOTE" },
+      createInstance: () => ({ placement: "floating" }),
+    });
+  },
+};