gloomberb 0.5.1 → 0.6.0

package/src/plugins/builtin/news-wire/breaking-notifications.ts

@@ -0,0 +1,110 @@
+import type { GloomPluginContext } from "../../../types/plugin";
+import type { MarketNewsItem, NewsQueryState } from "../../../types/news-source";
+import { NEWS_QUERY_PRESETS } from "./news-query-presets";
+
+export const BREAKING_NEWS_NOTIFICATIONS_ENABLED_KEY = "breakingNewsNotificationsEnabled";
+
+const MAX_SEEN_ARTICLE_IDS = 500;
+
+function isReadyState(state: NewsQueryState): boolean {
+  return state.phase === "ready" || state.phase === "refreshing";
+}
+
+function rememberArticleIds(current: Set<string>, articles: MarketNewsItem[]): Set<string> {
+  const next: string[] = [];
+  const included = new Set<string>();
+
+  for (const article of articles) {
+    if (included.has(article.id)) continue;
+    included.add(article.id);
+    next.push(article.id);
+  }
+
+  for (const id of current) {
+    if (included.has(id)) continue;
+    included.add(id);
+    next.push(id);
+    if (next.length >= MAX_SEEN_ARTICLE_IDS) break;
+  }
+
+  return new Set(next.slice(0, MAX_SEEN_ARTICLE_IDS));
+}
+
+function notificationSubtitle(article: MarketNewsItem): string {
+  const tickers = article.tickers.slice(0, 3).join(" ");
+  return tickers ? `${article.source} ${tickers}` : article.source;
+}
+
+function notifyNewBreakingArticles(ctx: GloomPluginContext, articles: MarketNewsItem[]): void {
+  const latest = [...articles].sort((a, b) => b.publishedAt.getTime() - a.publishedAt.getTime())[0];
+  if (!latest) return;
+
+  const extraCount = articles.length - 1;
+  ctx.notify({
+    title: "Breaking News",
+    subtitle: notificationSubtitle(latest),
+    body: extraCount > 0 ? `${latest.title} (+${extraCount} more)` : latest.title,
+    type: "info",
+    desktop: "always",
+    persistent: true,
+    action: {
+      label: "Open",
+      onClick: () => ctx.showPane("news-breaking"),
+    },
+  });
+}
+
+export function setupBreakingNewsNotifications(ctx: GloomPluginContext): () => void {
+  let disposeWatch: (() => void) | null = null;
+  let primed = false;
+  let seenArticleIds = new Set<string>();
+
+  const enabled = () => ctx.configState.get<boolean>(BREAKING_NEWS_NOTIFICATIONS_ENABLED_KEY) === true;
+
+  const handleState = (state: NewsQueryState) => {
+    if (!isReadyState(state)) return;
+
+    if (!primed) {
+      seenArticleIds = rememberArticleIds(seenArticleIds, state.articles);
+      primed = true;
+      return;
+    }
+
+    const freshArticles = state.articles.filter((article) => !seenArticleIds.has(article.id));
+    if (freshArticles.length === 0) return;
+
+    seenArticleIds = rememberArticleIds(seenArticleIds, state.articles);
+    if (enabled()) {
+      notifyNewBreakingArticles(ctx, freshArticles);
+    }
+  };
+
+  const stop = () => {
+    disposeWatch?.();
+    disposeWatch = null;
+    primed = false;
+    seenArticleIds = new Set();
+  };
+
+  const start = () => {
+    if (disposeWatch) return;
+    if (!ctx.watchNewsQuery) {
+      ctx.log.warn("breaking notifications unavailable: news query watcher missing");
+      return;
+    }
+    disposeWatch = ctx.watchNewsQuery(NEWS_QUERY_PRESETS.breaking, handleState);
+  };
+
+  const sync = () => {
+    if (enabled()) start();
+    else stop();
+  };
+
+  const disposeConfigListener = ctx.on("config:changed", sync);
+  sync();
+
+  return () => {
+    disposeConfigListener();
+    stop();
+  };
+}

package/src/plugins/builtin/news-wire/breaking-pane.tsx

@@ -0,0 +1,157 @@
+import { Box } from "../../../ui";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import type { PaneProps } from "../../../types/plugin";
+import { useNewsArticles } from "../../../news/hooks";
+import { useDebouncedPluginPaneState, usePluginPaneState } from "../../plugin-runtime";
+import { Spinner } from "../../../components";
+import type { MarketNewsItem } from "../../../types/news-source";
+import { detectProviders, getAiProvider, resolveDefaultAiProviderId } from "../ai/providers";
+import { runAiPrompt } from "../ai/runner";
+import { getDigest, setDigest, isDigestInFlight, markDigestInFlight, clearDigestInFlight } from "./digest-store";
+import { NewsDetailView, useNewsArticleDetail } from "./news-detail-view";
+import { NewsArticleStackView, type NewsSortPreference } from "./news-table";
+import { useNewsArticleFooter } from "./news-footer";
+import { NEWS_QUERY_PRESETS } from "./news-query-presets";
+import { usePersistedNewsArticles } from "./persisted-articles";
+import { useNewsReadState } from "./read-state";
+
+const DIGEST_PROMPT = `You are a financial news wire editor. Condense this headline and summary into a single concise actionable bullet point for a professional trader. Include why it matters and potential market impact. Keep it under 120 characters. Respond with ONLY the bullet text, nothing else.
+
+Headline: {title}
+Summary: {summary}`;
+
+const DEFAULT_SORT: NewsSortPreference = { columnId: "importance", direction: "desc" };
+const BRAILLE_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function buildDigestPrompt(item: MarketNewsItem): string {
+  return DIGEST_PROMPT
+    .replace("{title}", item.title)
+    .replace("{summary}", item.summary ?? item.title);
+}
+
+export function BreakingPane({ focused, width, height }: PaneProps) {
+  const breakingState = useNewsArticles(NEWS_QUERY_PRESETS.breaking);
+  const articles = usePersistedNewsArticles("breaking:articles", breakingState.articles);
+  const loading = breakingState.phase === "loading" || (breakingState.phase === "refreshing" && articles.length === 0);
+  const [selectedArticleId, setSelectedArticleId] = useDebouncedPluginPaneState<string | null>("breaking:selectedArticleId", null);
+  const [sortPreference, setSortPreference] = usePluginPaneState<NewsSortPreference>("breaking:sort", DEFAULT_SORT);
+  const [digestVersion, setDigestVersion] = useState(0);
+  const [aiAvailable, setAiAvailable] = useState(false);
+  const [aiError, setAiError] = useState<string | null>(null);
+  const [aiRunning, setAiRunning] = useState(false);
+  const [spinFrame, setSpinFrame] = useState(0);
+  const processingRef = useRef(false);
+  const { detailArticle, openArticle, closeDetail } = useNewsArticleDetail(articles);
+  const { readArticleIds, markArticleRead } = useNewsReadState();
+
+  useEffect(() => {
+    const providers = detectProviders();
+    setAiAvailable(providers.some((provider) => provider.available));
+  }, []);
+
+  useEffect(() => {
+    if (!aiRunning) return;
+    const id = setInterval(() => setSpinFrame((frame) => (frame + 1) % BRAILLE_FRAMES.length), 80);
+    return () => clearInterval(id);
+  }, [aiRunning]);
+
+  useEffect(() => {
+    if (!aiAvailable || articles.length === 0) return;
+    if (processingRef.current) return;
+
+    const providerId = resolveDefaultAiProviderId();
+    const provider = getAiProvider(providerId);
+    if (!provider?.available) return;
+
+    const toDigest = articles.filter((article) => !getDigest(article.id) && !isDigestInFlight(article.id));
+    if (toDigest.length === 0) return;
+
+    processingRef.current = true;
+    setAiRunning(true);
+
+    (async () => {
+      for (const article of toDigest) {
+        if (getDigest(article.id) || isDigestInFlight(article.id)) continue;
+        markDigestInFlight(article.id);
+
+        try {
+          const result = await runAiPrompt({
+            provider,
+            prompt: buildDigestPrompt(article),
+          }).done;
+
+          const digest = result.trim().slice(0, 150);
+          if (digest) {
+            setDigest(article.id, digest);
+            setDigestVersion((version) => version + 1);
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          if (message.includes("Credit") || message.includes("quota") || message.includes("rate limit")) {
+            setAiError(message);
+            break;
+          }
+        } finally {
+          clearDigestInFlight(article.id);
+        }
+      }
+      setAiRunning(false);
+      processingRef.current = false;
+    })();
+  }, [aiAvailable, articles]);
+
+  const titleForArticle = useCallback((article: MarketNewsItem) => (
+    getDigest(article.id) ?? article.title
+  ), [digestVersion]);
+
+  const footerInfo = useMemo(() => [
+    ...(aiRunning ? [{ id: "running", parts: [{ text: BRAILLE_FRAMES[spinFrame] ?? "running", tone: "positive" as const }] }] : []),
+    ...(aiError ? [{ id: "paused", parts: [{ text: "AI paused", tone: "warning" as const }] }] : []),
+  ], [aiError, aiRunning, spinFrame]);
+
+  useNewsArticleFooter({
+    registrationId: "news-wire:breaking",
+    focused,
+    article: detailArticle,
+    info: footerInfo,
+  });
+
+  const detailContent = detailArticle ? (
+    <NewsDetailView
+      item={detailArticle}
+      focused={focused}
+      width={width}
+      showTitle={false}
+    />
+  ) : (
+    <Box flexGrow={1} />
+  );
+
+  if (loading && articles.length === 0) {
+    return <Spinner label="Loading breaking news..." />;
+  }
+
+  return (
+    <NewsArticleStackView
+      articles={articles}
+      focused={focused}
+      width={width}
+      rootHeight={height}
+      readArticleIds={readArticleIds}
+      selectedArticleId={selectedArticleId}
+      setSelectedArticleId={setSelectedArticleId}
+      sortPreference={sortPreference}
+      setSortPreference={setSortPreference}
+      onOpenArticle={openArticle}
+      onArticleRead={markArticleRead}
+      detailOpen={!!detailArticle}
+      onBack={closeDetail}
+      detailContent={detailContent}
+      detailTitle={detailArticle?.title}
+      columns={["time", "title", "tickers", "importance"]}
+      emptyStateTitle="No breaking news"
+      emptyStateHint="Breaking stories appear when high-priority headlines arrive."
+      titleForArticle={titleForArticle}
+    />
+  );
+}

package/src/plugins/builtin/news-wire/categories.ts

@@ -0,0 +1,114 @@
+import type { MarketNewsItem } from "../../../types/news-source";
+
+const CATEGORY_KEYWORDS: Record<string, string[]> = {
+  tech: ["ai", "chip", "semiconductor", "software", "cloud", "cyber", "apple", "google", "microsoft", "meta", "nvidia", "amazon", "saas", "startup"],
+  energy: ["oil", "gas", "crude", "opec", "refinery", "solar", "wind", "pipeline", "lng", "drilling"],
+  finance: ["bank", "rate", "fed", "fomc", "treasury", "yield", "credit", "loan", "mortgage", "ipo"],
+  healthcare: ["pharma", "drug", "fda", "biotech", "vaccine", "hospital", "medicare"],
+  macro: ["gdp", "cpi", "inflation", "jobs", "unemployment", "trade", "tariff", "deficit", "pmi"],
+  earnings: ["earnings", "revenue", "eps", "beat", "miss", "guidance", "outlook", "quarterly"],
+  crypto: ["bitcoin", "ethereum", "crypto", "blockchain", "token", "defi", "mining"],
+  geopolitical: ["war", "sanctions", "nato", "military", "conflict", "diplomacy"],
+};
+
+const KNOWN_TICKERS = new Set([
+  "AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "TSLA", "JPM", "JNJ", "UNH",
+  "PG", "XOM", "CVX", "HD", "BAC", "V", "MA", "PFE", "KO", "PEP", "ABBV", "MRK",
+  "LLY", "COST", "AVGO", "CRM", "NFLX", "AMD", "INTC", "QCOM", "IBM", "GS", "MS",
+  "WFC", "C", "DIS", "PYPL", "SQ", "COIN", "PLTR", "SNOW", "CRWD",
+]);
+
+export function classifyArticle(item: MarketNewsItem): string[] {
+  const text = `${item.title} ${item.summary ?? ""}`.toLowerCase();
+  const matched: string[] = [];
+
+  for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+    for (const kw of keywords) {
+      if (text.includes(kw)) {
+        matched.push(category);
+        break;
+      }
+    }
+  }
+
+  return matched;
+}
+
+export function extractTickers(text: string, knownTickers?: Set<string>): string[] {
+  const combined = new Set([...KNOWN_TICKERS, ...(knownTickers ?? [])]);
+  const matches = text.match(/\b[A-Z]{1,5}\b/g) ?? [];
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const m of matches) {
+    if (combined.has(m) && !seen.has(m)) {
+      seen.add(m);
+      result.push(m);
+    }
+  }
+
+  return result;
+}
+
+const BREAKING_PATTERNS = [
+  /\bbreaking\b/i,
+  /\bjust in\b/i,
+  /\bflash\b/i,
+  /\balert\b/i,
+  /\burgent\b/i,
+];
+
+export function detectBreaking(title: string, publishedAt: Date, authority: number): boolean {
+  for (const re of BREAKING_PATTERNS) {
+    if (re.test(title)) return true;
+  }
+
+  const ageMs = Date.now() - publishedAt.getTime();
+  if (authority >= 70 && ageMs < 10 * 60 * 1000) return true;
+
+  return false;
+}
+
+export function scoreImportance(authority: number, publishedAt: Date, isBreaking: boolean): number {
+  const ageMs = Date.now() - publishedAt.getTime();
+  let score = authority;
+
+  if (ageMs < 30 * 60 * 1000) score += 20;
+  else if (ageMs < 2 * 60 * 60 * 1000) score += 10;
+
+  if (isBreaking) score += 30;
+
+  return Math.min(100, score);
+}
+
+export function enrichNewsItem(item: MarketNewsItem, authority = 50, knownTickers?: Set<string>): MarketNewsItem {
+  const categories = item.categories.length > 0
+    ? [...new Set([...item.categories, ...classifyArticle(item)])]
+    : classifyArticle(item);
+
+  const text = `${item.title} ${item.summary ?? ""}`;
+  const tickers = extractTickers(text, knownTickers);
+  const isBreaking = detectBreaking(item.title, item.publishedAt, authority);
+  const importance = scoreImportance(authority, item.publishedAt, isBreaking);
+  const topic = categories[0] ?? item.topic ?? "general";
+  const scores = {
+    importance,
+    urgency: isBreaking ? 80 : Math.min(100, Math.max(0, importance - 10)),
+    marketImpact: importance,
+    novelty: item.scores?.novelty ?? 0,
+    confidence: item.scores?.confidence ?? 0,
+  };
+
+  return {
+    ...item,
+    topic,
+    topics: [...new Set([topic, ...(item.topics ?? []), ...categories])],
+    sectors: item.sectors ?? [],
+    categories,
+    tickers,
+    scores,
+    isBreaking,
+    isDeveloping: item.isDeveloping ?? false,
+    importance,
+  };
+}

package/src/plugins/builtin/news-wire/default-feeds.ts

@@ -0,0 +1,3 @@
+import type { RssFeedConfig } from "./rss-parser";
+
+export const DEFAULT_FEEDS: RssFeedConfig[] = [];

package/src/plugins/builtin/news-wire/digest-store.ts

@@ -0,0 +1,44 @@
+import type { PluginPersistence } from "../../../types/plugin";
+
+const CACHE_POLICY = {
+  staleMs: 7 * 86_400_000,   // 7 days
+  expireMs: 30 * 86_400_000, // 30 days
+};
+
+const cache = new Map<string, string>();
+const inFlight = new Set<string>();
+let persist: PluginPersistence | null = null;
+
+export function setDigestPersistence(p: PluginPersistence): void {
+  persist = p;
+}
+
+export function getDigest(articleId: string): string | null {
+  const cached = cache.get(articleId);
+  if (cached !== undefined) return cached;
+
+  if (!persist) return null;
+  const res = persist.getResource<string>("ai-digest", articleId, { allowExpired: false });
+  if (res) {
+    cache.set(articleId, res.value);
+    return res.value;
+  }
+  return null;
+}
+
+export function setDigest(articleId: string, digest: string): void {
+  cache.set(articleId, digest);
+  persist?.setResource("ai-digest", articleId, digest, { cachePolicy: CACHE_POLICY });
+}
+
+export function isDigestInFlight(articleId: string): boolean {
+  return inFlight.has(articleId);
+}
+
+export function markDigestInFlight(articleId: string): void {
+  inFlight.add(articleId);
+}
+
+export function clearDigestInFlight(articleId: string): void {
+  inFlight.delete(articleId);
+}

package/src/plugins/builtin/news-wire/feed-config.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import type { PluginConfigState } from "../../../types/plugin";
+import {
+  addUserNewsFeed,
+  createUserFeed,
+  getEnabledNewsFeeds,
+  loadNewsFeedSettings,
+  removeUserNewsFeed,
+  setDefaultNewsFeedEnabled,
+  updateUserNewsFeed,
+} from "./feed-config";
+
+class MemoryConfigState implements PluginConfigState {
+  values = new Map<string, unknown>();
+
+  get<T = unknown>(key: string): T | null {
+    return (this.values.get(key) as T | undefined) ?? null;
+  }
+
+  async set(key: string, value: unknown): Promise<void> {
+    this.values.set(key, value);
+  }
+
+  async delete(key: string): Promise<void> {
+    this.values.delete(key);
+  }
+
+  keys(): string[] {
+    return [...this.values.keys()];
+  }
+}
+
+describe("news feed config", () => {
+  test("normalizes legacy JSON feed storage and ignores removed default feed names", () => {
+    const config = new MemoryConfigState();
+    config.values.set("feeds", JSON.stringify([
+      { url: "https://example.com/rss.xml", name: "Example", authority: 120 },
+      { url: "ftp://example.com/invalid.xml", name: "Invalid" },
+    ]));
+    config.values.set("disabledDefaultFeeds", JSON.stringify(["CNBC", "missing"]));
+
+    const settings = loadNewsFeedSettings(config);
+
+    expect(settings.userFeeds).toHaveLength(1);
+    expect(settings.userFeeds[0]!.id).toMatch(/^user-/);
+    expect(settings.userFeeds[0]!.authority).toBe(100);
+    expect(settings.disabledDefaultFeedIds).toEqual([]);
+  });
+
+  test("adds, updates, and removes user feeds through typed helpers", async () => {
+    const config = new MemoryConfigState();
+
+    const added = await addUserNewsFeed(config, {
+      url: "https://example.com/feed",
+      name: "Example",
+      category: "Tech",
+    });
+    expect(added.category).toBe("tech");
+
+    const updated = await updateUserNewsFeed(config, added.id, {
+      name: "Example Markets",
+      authority: 75,
+    });
+    expect(updated?.name).toBe("Example Markets");
+    expect(updated?.authority).toBe(75);
+
+    const removed = await removeUserNewsFeed(config, added.id);
+    expect(removed).toBe(true);
+    expect(loadNewsFeedSettings(config).userFeeds).toHaveLength(0);
+  });
+
+  test("returns only user feeds when the default feed catalog is empty", async () => {
+    const config = new MemoryConfigState();
+
+    expect(getEnabledNewsFeeds(loadNewsFeedSettings(config))).toEqual([]);
+
+    const added = await addUserNewsFeed(config, {
+      url: "https://example.com/feed",
+      name: "Example",
+    });
+
+    expect(getEnabledNewsFeeds(loadNewsFeedSettings(config)).map((feed) => feed.id)).toEqual([added.id]);
+    expect(await setDefaultNewsFeedEnabled(config, "missing-default-feed", false)).toBe(false);
+  });
+
+  test("rejects invalid user feed input", () => {
+    expect(() => createUserFeed({ url: "not-url", name: "Bad" })).toThrow("Feed URL");
+    expect(() => createUserFeed({ url: "https://example.com/feed", name: "" })).toThrow("Feed name");
+  });
+});