gloomberb 0.5.0 → 0.6.0

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

@@ -0,0 +1,216 @@
+import type { PluginConfigState } from "../../../types/plugin";
+import { DEFAULT_FEEDS } from "./default-feeds";
+import { hashString } from "./hash";
+import type { RssFeedConfig } from "./rss-parser";
+
+const USER_FEEDS_KEY = "feeds";
+const DISABLED_DEFAULT_FEED_IDS_KEY = "disabledDefaultFeedIds";
+const LEGACY_DISABLED_DEFAULT_FEEDS_KEY = "disabledDefaultFeeds";
+
+const DEFAULT_FEED_IDS = new Set(DEFAULT_FEEDS.map((feed) => feed.id));
+
+export interface NewsFeedSettings {
+  userFeeds: RssFeedConfig[];
+  disabledDefaultFeedIds: string[];
+  migrated: boolean;
+}
+
+export interface UserNewsFeedInput {
+  id?: string;
+  url: string;
+  name: string;
+  category?: string;
+  authority?: number;
+  enabled?: boolean;
+}
+
+function parseJsonArray(value: unknown): unknown[] {
+  if (Array.isArray(value)) return value;
+  if (typeof value !== "string" || !value.trim()) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function normalizeUrl(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!/^https?:\/\//i.test(trimmed)) return null;
+  return trimmed;
+}
+
+function normalizeName(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function normalizeCategory(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim().toLowerCase();
+  return trimmed || undefined;
+}
+
+function normalizeAuthority(value: unknown, fallback: number): number {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(0, Math.min(100, Math.round(parsed)));
+}
+
+export function createUserFeedId(url: string, name: string): string {
+  return `user-${hashString(`${url}|${name}`)}`;
+}
+
+export function createUserFeed(input: UserNewsFeedInput): RssFeedConfig {
+  const url = normalizeUrl(input.url);
+  const name = normalizeName(input.name);
+  if (!url) throw new Error("Feed URL must be an http(s) URL.");
+  if (!name) throw new Error("Feed name is required.");
+
+  return {
+    id: input.id?.trim() || createUserFeedId(url, name),
+    url,
+    name,
+    category: normalizeCategory(input.category) ?? "general",
+    authority: normalizeAuthority(input.authority, 50),
+    enabled: input.enabled !== false,
+  };
+}
+
+function normalizeUserFeed(value: unknown): RssFeedConfig | null {
+  if (!value || typeof value !== "object") return null;
+  const record = value as Record<string, unknown>;
+  try {
+    return createUserFeed({
+      id: typeof record.id === "string" ? record.id : undefined,
+      url: String(record.url ?? ""),
+      name: String(record.name ?? ""),
+      category: typeof record.category === "string" ? record.category : undefined,
+      authority: typeof record.authority === "number" ? record.authority : undefined,
+      enabled: record.enabled !== false,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function normalizeDisabledDefaultFeedIds(values: unknown[]): string[] {
+  const legacyNameToId = new Map(DEFAULT_FEEDS.map((feed) => [feed.name, feed.id]));
+  const ids = new Set<string>();
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    const id = DEFAULT_FEED_IDS.has(trimmed) ? trimmed : legacyNameToId.get(trimmed);
+    if (id) ids.add(id);
+  }
+  return [...ids];
+}
+
+export function loadNewsFeedSettings(configState: PluginConfigState): NewsFeedSettings {
+  const rawUserFeeds = configState.get<unknown>(USER_FEEDS_KEY);
+  const userFeedValues = parseJsonArray(rawUserFeeds);
+  const userFeeds = userFeedValues
+    .map(normalizeUserFeed)
+    .filter((feed): feed is RssFeedConfig => !!feed);
+
+  const rawDisabledIds = configState.get<unknown>(DISABLED_DEFAULT_FEED_IDS_KEY);
+  const rawLegacyDisabled = configState.get<unknown>(LEGACY_DISABLED_DEFAULT_FEEDS_KEY);
+  const disabledDefaultFeedIds = normalizeDisabledDefaultFeedIds([
+    ...parseJsonArray(rawDisabledIds),
+    ...parseJsonArray(rawLegacyDisabled),
+  ]);
+
+  const migrated = rawUserFeeds !== null
+    || rawDisabledIds !== null
+    || rawLegacyDisabled !== null;
+
+  return { userFeeds, disabledDefaultFeedIds, migrated };
+}
+
+export async function saveNewsFeedSettings(
+  configState: PluginConfigState,
+  settings: Pick<NewsFeedSettings, "userFeeds" | "disabledDefaultFeedIds">,
+): Promise<void> {
+  await configState.set(USER_FEEDS_KEY, settings.userFeeds);
+  await configState.set(DISABLED_DEFAULT_FEED_IDS_KEY, settings.disabledDefaultFeedIds);
+  await configState.delete(LEGACY_DISABLED_DEFAULT_FEEDS_KEY);
+}
+
+export function getEnabledNewsFeeds(settings: Pick<NewsFeedSettings, "userFeeds" | "disabledDefaultFeedIds">): RssFeedConfig[] {
+  const disabled = new Set(settings.disabledDefaultFeedIds);
+  return [
+    ...DEFAULT_FEEDS.filter((feed) => feed.enabled && !disabled.has(feed.id)),
+    ...settings.userFeeds.filter((feed) => feed.enabled),
+  ];
+}
+
+export async function addUserNewsFeed(
+  configState: PluginConfigState,
+  input: UserNewsFeedInput,
+): Promise<RssFeedConfig> {
+  const settings = loadNewsFeedSettings(configState);
+  const feed = createUserFeed(input);
+  const nextUserFeeds = [
+    ...settings.userFeeds.filter((entry) => entry.id !== feed.id),
+    feed,
+  ];
+  await saveNewsFeedSettings(configState, {
+    userFeeds: nextUserFeeds,
+    disabledDefaultFeedIds: settings.disabledDefaultFeedIds,
+  });
+  return feed;
+}
+
+export async function updateUserNewsFeed(
+  configState: PluginConfigState,
+  feedId: string,
+  patch: Partial<UserNewsFeedInput>,
+): Promise<RssFeedConfig | null> {
+  const settings = loadNewsFeedSettings(configState);
+  const existing = settings.userFeeds.find((feed) => feed.id === feedId);
+  if (!existing) return null;
+  const nextFeed = createUserFeed({
+    ...existing,
+    ...patch,
+    id: feedId,
+  });
+  await saveNewsFeedSettings(configState, {
+    userFeeds: settings.userFeeds.map((feed) => feed.id === feedId ? nextFeed : feed),
+    disabledDefaultFeedIds: settings.disabledDefaultFeedIds,
+  });
+  return nextFeed;
+}
+
+export async function removeUserNewsFeed(
+  configState: PluginConfigState,
+  feedId: string,
+): Promise<boolean> {
+  const settings = loadNewsFeedSettings(configState);
+  const nextUserFeeds = settings.userFeeds.filter((feed) => feed.id !== feedId);
+  if (nextUserFeeds.length === settings.userFeeds.length) return false;
+  await saveNewsFeedSettings(configState, {
+    userFeeds: nextUserFeeds,
+    disabledDefaultFeedIds: settings.disabledDefaultFeedIds,
+  });
+  return true;
+}
+
+export async function setDefaultNewsFeedEnabled(
+  configState: PluginConfigState,
+  feedId: string,
+  enabled: boolean,
+): Promise<boolean> {
+  if (!DEFAULT_FEED_IDS.has(feedId)) return false;
+  const settings = loadNewsFeedSettings(configState);
+  const disabled = new Set(settings.disabledDefaultFeedIds);
+  if (enabled) disabled.delete(feedId);
+  else disabled.add(feedId);
+  await saveNewsFeedSettings(configState, {
+    userFeeds: settings.userFeeds,
+    disabledDefaultFeedIds: [...disabled],
+  });
+  return true;
+}

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

@@ -0,0 +1,21 @@
+import type { PaneProps } from "../../../types/plugin";
+import { NEWS_QUERY_PRESETS } from "./news-query-presets";
+import { NewsPresetPane } from "./news-preset-pane";
+import type { NewsSortPreference } from "./news-table";
+
+const DEFAULT_SORT: NewsSortPreference = { columnId: "time", direction: "desc" };
+
+export function FeedPane(props: PaneProps) {
+  return (
+    <NewsPresetPane
+      {...props}
+      paneKey="feed"
+      title="News Feed"
+      query={NEWS_QUERY_PRESETS.feed}
+      columns={["time", "source", "title", "tickers", "categories"]}
+      defaultSort={DEFAULT_SORT}
+      emptyStateTitle="No feed stories yet"
+      emptyStateHint="Try refreshing later as wire stories arrive."
+    />
+  );
+}

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

@@ -0,0 +1,9 @@
+
+export function hashString(value: string): string {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = (hash * 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}

package/src/plugins/builtin/news-wire/index.tsx

@@ -0,0 +1,92 @@
+import type { GloomPluginContext } from "../../../types/plugin";
+import { createRssNewsCapability } from "./rss-source";
+import { TopPane } from "./top-pane";
+import { FeedPane } from "./feed-pane";
+import { IndustryPane } from "./industry-pane";
+import { BreakingPane } from "./breaking-pane";
+import {
+  BREAKING_NEWS_NOTIFICATIONS_ENABLED_KEY,
+  setupBreakingNewsNotifications,
+} from "./breaking-notifications";
+import { setDigestPersistence } from "./digest-store";
+import {
+  addUserNewsFeed,
+  getEnabledNewsFeeds,
+  loadNewsFeedSettings,
+  saveNewsFeedSettings,
+} from "./feed-config";
+
+export function registerNewsWireFeatures(ctx: GloomPluginContext): () => void {
+  setDigestPersistence(ctx.persistence);
+  ctx.registerPane({ id: "news-top", name: "Top News", icon: "T", component: TopPane, defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 90, height: 30 } });
+  ctx.registerPane({ id: "news-feed", name: "News Feed", icon: "N", component: FeedPane, defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 100, height: 35 } });
+  ctx.registerPane({ id: "news-industry", name: "Sector News", icon: "S", component: IndustryPane, defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 100, height: 35 } });
+  ctx.registerPane({
+    id: "news-breaking",
+    name: "Breaking News",
+    icon: "!",
+    component: BreakingPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 85, height: 20 },
+    settings: {
+      title: "Breaking News Settings",
+      fields: [{
+        key: BREAKING_NEWS_NOTIFICATIONS_ENABLED_KEY,
+        label: "Notifications",
+        description: "Notify when new breaking stories arrive, even while this pane is closed.",
+        type: "toggle",
+        storage: "plugin",
+      }],
+    },
+  });
+
+  ctx.registerPaneTemplate({ id: "news-top-pane", paneId: "news-top", label: "Top News", description: "Curated top market stories ranked by importance", keywords: ["top", "news", "headlines", "stories"], shortcut: { prefix: "TOP" } });
+  ctx.registerPaneTemplate({ id: "news-feed-pane", paneId: "news-feed", label: "News Feed", description: "Chronological market news firehose", keywords: ["news", "feed", "firehose", "wire", "stream"], shortcut: { prefix: "N" } });
+  ctx.registerPaneTemplate({ id: "news-industry-pane", paneId: "news-industry", label: "Sector News", description: "Market news filtered by sector", keywords: ["news", "industry", "sector", "ni", "filter"], shortcut: { prefix: "NI" } });
+  ctx.registerPaneTemplate({ id: "news-breaking-pane", paneId: "news-breaking", label: "Breaking News", description: "Breaking and urgent market news", keywords: ["first", "breaking", "urgent", "alert", "flash"], shortcut: { prefix: "FIRST" } });
+
+  const initialSettings = loadNewsFeedSettings(ctx.configState);
+  if (initialSettings.migrated) {
+    void saveNewsFeedSettings(ctx.configState, initialSettings);
+  }
+
+  const source = createRssNewsCapability(
+    () => getEnabledNewsFeeds(loadNewsFeedSettings(ctx.configState)),
+    { persistence: ctx.persistence },
+  );
+  ctx.registerCapability(source);
+
+  ctx.registerCommand({
+    id: "add-news-feed",
+    label: "Add News Feed",
+    keywords: ["news", "rss", "feed", "add", "source"],
+    category: "config",
+    description: "Add a custom RSS news feed",
+    wizardLayout: "form",
+    wizard: [
+      { key: "url", label: "Feed URL", type: "text", placeholder: "https://example.com/rss" },
+      { key: "name", label: "Feed Name", type: "text", placeholder: "My Feed" },
+      { key: "category", label: "Category", type: "select", options: [
+        { label: "General", value: "general" },
+        { label: "Tech", value: "tech" },
+        { label: "Energy", value: "energy" },
+        { label: "Finance", value: "finance" },
+        { label: "Healthcare", value: "healthcare" },
+        { label: "Macro", value: "macro" },
+        { label: "Crypto", value: "crypto" },
+      ]},
+    ],
+    async execute(values) {
+      const url = values?.url?.trim();
+      const name = values?.name?.trim();
+      const category = values?.category ?? "general";
+      if (!url || !name) return;
+
+      const feed = await addUserNewsFeed(ctx.configState, { url, name, category });
+      ctx.notify({ body: `Added news feed: ${feed.name}`, type: "success" });
+    },
+  });
+
+  return setupBreakingNewsNotifications(ctx);
+}

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

@@ -0,0 +1,140 @@
+import { Box } from "../../../ui";
+import { useEffect, useMemo } from "react";
+import type { PaneProps } from "../../../types/plugin";
+import type { MarketNewsItem } from "../../../types/news-source";
+import { useNewsArticles } from "../../../news/hooks";
+import type { NewsQueryPhase } from "../../../news/types";
+import { useDebouncedPluginPaneState, usePluginPaneState } from "../../plugin-runtime";
+import { Spinner, Tabs } from "../../../components";
+import { NewsDetailView, useNewsArticleDetail } from "./news-detail-view";
+import { NewsArticleStackView, type NewsSortPreference } from "./news-table";
+import { useNewsArticleFooter } from "./news-footer";
+import { useNewsReadState } from "./read-state";
+import { usePersistedNewsArticles } from "./persisted-articles";
+import {
+  NEWS_QUERY_PRESETS,
+  SECTOR_NEWS_SECTORS,
+  type SectorNewsSelection,
+  sectorNewsLabel,
+} from "./news-query-presets";
+
+const SECTOR_TABS = ["all", ...SECTOR_NEWS_SECTORS] as const;
+
+const DEFAULT_SORT: NewsSortPreference = { columnId: "time", direction: "desc" };
+
+function useIndustryArticles(sector: SectorNewsSelection): { articles: MarketNewsItem[]; allArticles: MarketNewsItem[]; phase: NewsQueryPhase } {
+  const allState = useNewsArticles(NEWS_QUERY_PRESETS.sectorAll);
+  const sectorState = useNewsArticles(
+    sector === "all" ? null : NEWS_QUERY_PRESETS.sector(sector),
+  );
+  const allArticles = usePersistedNewsArticles("industry:sector:all:articles", allState.articles);
+  const sectorArticles = usePersistedNewsArticles(`industry:sector:${sector}:articles`, sectorState.articles);
+  const phase = sector === "all" ? allState.phase : sectorState.phase;
+  return {
+    articles: sector === "all" ? allArticles : sectorArticles,
+    allArticles,
+    phase,
+  };
+}
+
+export function IndustryPane({ focused, width, height }: PaneProps) {
+  const [category, setCategory] = usePluginPaneState<SectorNewsSelection>("industry:category", "all");
+  const [selectedArticleId, setSelectedArticleId] = useDebouncedPluginPaneState<string | null>("industry:selectedArticleId", null);
+  const [sortPreference, setSortPreference] = usePluginPaneState<NewsSortPreference>("industry:sort", DEFAULT_SORT);
+  const { articles, allArticles, phase } = useIndustryArticles(category);
+  const loading = phase === "loading" || (phase === "refreshing" && articles.length === 0);
+  const { detailArticle, openArticle, closeDetail } = useNewsArticleDetail(articles);
+  const { readArticleIds, markArticleRead } = useNewsReadState();
+  const counts = useMemo(() => {
+    const next: Record<string, number> = { all: allArticles.length };
+    for (const cat of SECTOR_TABS) {
+      if (cat === "all") continue;
+      next[cat] = allArticles.filter((article) => (
+        article.sectors.some((entry) => entry.toLowerCase() === cat)
+      )).length;
+    }
+    return next;
+  }, [allArticles]);
+  const tabs = useMemo(() => SECTOR_TABS.map((cat) => ({
+    value: cat,
+    label: counts[cat] ? `${sectorNewsLabel(cat)} ${counts[cat]}` : sectorNewsLabel(cat),
+  })), [counts]);
+
+  useEffect(() => {
+    setSelectedArticleId(null);
+  }, [category, setSelectedArticleId]);
+
+  const handleRootKeyDown = (event: {
+    name?: string;
+    preventDefault?: () => void;
+    stopPropagation?: () => void;
+  }) => {
+    if (event.name !== "left" && event.name !== "right" && event.name !== "h" && event.name !== "l") return;
+    event.stopPropagation?.();
+    event.preventDefault?.();
+    const index = SECTOR_TABS.indexOf(category);
+    const delta = event.name === "left" || event.name === "h" ? -1 : 1;
+    const nextIndex = Math.max(0, Math.min(SECTOR_TABS.length - 1, index + delta));
+    setCategory(SECTOR_TABS[nextIndex]!);
+    return true;
+  };
+
+  useNewsArticleFooter({
+    registrationId: "news-wire:industry",
+    focused,
+    article: detailArticle,
+  });
+
+  const rootBefore = (
+    <Box height={1} flexShrink={0} overflow="hidden">
+      <Tabs
+        tabs={tabs}
+        activeValue={category}
+        onSelect={(value) => setCategory(value as SectorNewsSelection)}
+        compact
+        variant="bare"
+      />
+    </Box>
+  );
+
+  const detailContent = detailArticle ? (
+    <NewsDetailView
+      item={detailArticle}
+      focused={focused}
+      width={width}
+      showTitle={false}
+    />
+  ) : (
+    <Box flexGrow={1} />
+  );
+
+  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}
+      rootBefore={rootBefore}
+      onRootKeyDown={handleRootKeyDown}
+      columns={["time", "source", "title", "tickers", "categories"]}
+      emptyContent={loading && articles.length === 0 ? (
+        <Box width="100%" paddingX={1} paddingY={1}>
+          <Spinner label="Loading sector news..." />
+        </Box>
+      ) : undefined}
+      emptyStateTitle="No news in this category"
+      emptyStateHint="Try another category or wait for the next feed refresh."
+    />
+  );
+}