gloomberb 0.5.0 → 0.6.0

package/src/plugins/builtin/news.tsx

@@ -1,31 +1,38 @@
-import { useRef, useEffect, useState } from "react";
-import type { GloomPlugin, DetailTabProps } from "../../types/plugin";
+import { Text } from "../../ui";
+import { useRef, useEffect, useMemo, useState } from "react";
+import type { DetailTabProps, GloomPlugin, PaneProps } 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 type { NewsArticle } from "../../types/news-source";
+import { useArticleSummary, 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";
+import { useDebouncedPluginPaneState } from "../../plugins/plugin-runtime";
+import { FeedDataTableStackView, Spinner, type FeedDataTableItem } from "../../components";
+import { useNewsArticles } from "../../news/hooks";
+import { registerNewsWireFeatures } from "./news-wire";
+import { useNewsArticleFooter } from "./news-wire/news-footer";
+import { usePersistedNewsArticles } from "./news-wire/persisted-articles";
+import { useNewsReadState } from "./news-wire/read-state";
+import { createTickerSurfacePaneTemplate } from "./ticker-surface";
 
 const ARTICLE_SUMMARY_CACHE_POLICY = {
   staleMs: 30 * 24 * 60 * 60_000,
   expireMs: 90 * 24 * 60 * 60_000,
 };
 const NEWS_ITEM_LIMIT = 50;
+let disposeNewsWireFeatures: (() => void) | null = null;
 
 function getFeedItems(
-  news: NewsItem[],
+  news: NewsArticle[],
   selectedUrl: string | undefined,
   summaryCache: Map<string, string>,
   loadingSummary: boolean,
-): DetailFeedItem[] {
+): FeedDataTableItem[] {
   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()}`,
+      id: item.id,
       eyebrow: item.source,
       title: item.title,
       timestamp: item.publishedAt,
@@ -49,26 +56,39 @@ function getFeedItems(
   });
 }
 
-function NewsTab({ width, height, focused }: DetailTabProps) {
+export function TickerNewsView({ width, height, focused }: Pick<DetailTabProps, "width" | "height" | "focused">) {
   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 [selectedIdx, setSelectedIdx] = useDebouncedPluginPaneState<number>(selectionKey, 0);
   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;
+  const newsState = useNewsArticles(instrument ? {
+    feed: "ticker",
+    ticker: instrument.symbol,
+    exchange: instrument.exchange,
+    tickerTier: "primary",
+    limit: NEWS_ITEM_LIMIT,
+  } : null);
+  const liveNews = newsState.articles;
+  const news = usePersistedNewsArticles(
+    `articles:${instrument?.symbol ?? "none"}:${instrument?.exchange ?? ""}`,
+    liveNews,
+  );
+  const { readArticleIds, markArticleRead } = useNewsReadState();
+  const [openItemId, setOpenItemId] = useState<string | null>(null);
+  const loading = newsState.phase === "loading" || (newsState.phase === "refreshing" && news.length === 0);
+  const error = newsState.phase === "error" ? newsState.error ?? "Failed to load news" : null;
 
   useEffect(() => {
     summaryFetchRef.current += 1;
     setSummaryCache(new Map());
-    setHoveredIdx(null);
   }, [ticker?.metadata.ticker]);
 
   const selected = news[selectedIdx];
+  const openArticle = openItemId
+    ? news.find((article) => article.id === openItemId) ?? null
+    : null;
   const cachedSelectedSummary = selected ? summaryCache.get(selected.url) : undefined;
   const articleSummaryEntry = useArticleSummary(
     selected && !selected.summary && !cachedSelectedSummary ? selected.url : null,
@@ -93,28 +113,52 @@ function NewsTab({ width, height, focused }: DetailTabProps) {
     }
   }, [news.length, selectedIdx, setSelectedIdx]);
 
-  if (!ticker) return <text fg={colors.textDim}>Select a ticker to view news.</text>;
+  const footerInfo = useMemo(() => [
+    ...(loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
+    ...(error ? [{ id: "error", parts: [{ text: "error", tone: "warning" as const }] }] : []),
+    ...(loadingSummary ? [{ id: "summary", parts: [{ text: "summary loading", tone: "muted" as const }] }] : []),
+  ], [error, loading, loadingSummary]);
+
+  useNewsArticleFooter({
+    registrationId: "news",
+    focused,
+    article: openArticle,
+    info: footerInfo,
+  });
+
+  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>;
+  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
+    <FeedDataTableStackView
       width={width}
       height={height}
       focused={focused}
       items={items}
       selectedIdx={selectedIdx}
-      hoveredIdx={hoveredIdx}
       onSelect={setSelectedIdx}
-      onHover={setHoveredIdx}
-      listVariant="single-line"
+      isItemRead={(item) => readArticleIds.has(item.id)}
+      onOpenItem={(item) => markArticleRead(item.id)}
+      onOpenItemIdChange={setOpenItemId}
+      sourceLabel="Source"
+      titleLabel="Headline"
+      emptyStateTitle="No news."
     />
   );
 }
 
+function NewsTab(props: DetailTabProps) {
+  return <TickerNewsView {...props} />;
+}
+
+function TickerNewsPane({ focused, width, height }: PaneProps) {
+  return <TickerNewsView focused={focused} width={width} height={height} />;
+}
+
 export const newsPlugin: GloomPlugin = {
   id: "news",
   name: "News",
@@ -122,6 +166,29 @@ export const newsPlugin: GloomPlugin = {
   description: "View latest news for each ticker",
   toggleable: true,
 
+  panes: [
+    {
+      id: "ticker-news",
+      name: "Ticker News",
+      icon: "C",
+      component: TickerNewsPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 100, height: 32 },
+    },
+  ],
+
+  paneTemplates: [
+    createTickerSurfacePaneTemplate({
+      id: "ticker-news-pane",
+      paneId: "ticker-news",
+      label: "Ticker News",
+      description: "Company news for the selected ticker.",
+      keywords: ["company", "ticker", "news", "headlines", "cn"],
+      shortcut: "CN",
+    }),
+  ],
+
   setup(ctx) {
     ctx.registerDetailTab({
       id: "news",
@@ -129,5 +196,11 @@ export const newsPlugin: GloomPlugin = {
       order: 40,
       component: NewsTab,
     });
+    disposeNewsWireFeatures = registerNewsWireFeatures(ctx);
+  },
+
+  dispose() {
+    disposeNewsWireFeatures?.();
+    disposeNewsWireFeatures = null;
   },
 };

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

@@ -1,47 +1,88 @@
-import { unlink, readFile, writeFile } from "fs/promises";
-import { join } from "path";
-
 export interface QuickNoteEntry {
   id: string;
   title: string;
+  updatedAt?: number;
 }
 
 const QUICK_NOTES_INDEX = "__quick-notes-index__";
 
+function joinPath(...parts: string[]): string {
+  return parts.join("/").replace(/\/+/g, "/");
+}
+
+interface LocalStorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+function getLocalStorage(): LocalStorageLike | null {
+  return (globalThis as { localStorage?: LocalStorageLike }).localStorage ?? null;
+}
+
+async function readTextFile(path: string): Promise<string> {
+  if (typeof Bun !== "undefined") {
+    const fsModulePath = "fs/promises";
+    const { readFile } = await import(fsModulePath) as typeof import("fs/promises");
+    return readFile(path, "utf-8");
+  }
+  return getLocalStorage()?.getItem(`gloomberb:notes:${path}`) ?? "";
+}
+
+async function writeTextFile(path: string, value: string): Promise<void> {
+  if (typeof Bun !== "undefined") {
+    const fsModulePath = "fs/promises";
+    const { writeFile } = await import(fsModulePath) as typeof import("fs/promises");
+    await writeFile(path, value, "utf-8");
+    return;
+  }
+  getLocalStorage()?.setItem(`gloomberb:notes:${path}`, value);
+}
+
+async function deleteTextFile(path: string): Promise<void> {
+  if (typeof Bun !== "undefined") {
+    const fsModulePath = "fs/promises";
+    const { unlink } = await import(fsModulePath) as typeof import("fs/promises");
+    await unlink(path);
+    return;
+  }
+  getLocalStorage()?.removeItem(`gloomberb:notes:${path}`);
+}
+
 export class NotesFiles {
   constructor(private readonly dataDir: string) {}
 
   private pathFor(symbol: string): string {
-    return join(this.dataDir, `${symbol}.md`);
+    return joinPath(this.dataDir, `${symbol}.md`);
   }
 
   async load(symbol: string): Promise<string> {
     try {
-      return await readFile(this.pathFor(symbol), "utf-8");
+      return await readTextFile(this.pathFor(symbol));
     } catch {
       return "";
     }
   }
 
   async save(symbol: string, notes: string): Promise<void> {
-    await writeFile(this.pathFor(symbol), notes || "", "utf-8");
+    await writeTextFile(this.pathFor(symbol), notes || "");
   }
 
   async delete(symbol: string): Promise<void> {
     try {
-      await unlink(this.pathFor(symbol));
+      await deleteTextFile(this.pathFor(symbol));
     } catch {
       // ignore missing files
     }
   }
 
   private indexPath(): string {
-    return join(this.dataDir, `${QUICK_NOTES_INDEX}.json`);
+    return joinPath(this.dataDir, `${QUICK_NOTES_INDEX}.json`);
   }
 
   async loadQuickNotesIndex(): Promise<QuickNoteEntry[]> {
     try {
-      const raw = await readFile(this.indexPath(), "utf-8");
+      const raw = await readTextFile(this.indexPath());
       return JSON.parse(raw);
     } catch {
       return [];
@@ -49,7 +90,7 @@ export class NotesFiles {
   }
 
   async saveQuickNotesIndex(entries: QuickNoteEntry[]): Promise<void> {
-    await writeFile(this.indexPath(), JSON.stringify(entries), "utf-8");
+    await writeTextFile(this.indexPath(), JSON.stringify(entries));
   }
 
   quickNoteKey(id: string): string {