gloomberb 0.5.0 → 0.6.0

package/src/news/aggregator.ts

@@ -0,0 +1,452 @@
+import { canonicalExchange, normalizeSymbol } from "../utils/exchanges";
+import type { NewsCapability } from "../capabilities";
+import type { NewsArticle, NewsFeed, NewsQuery, NewsQueryState } from "./types";
+
+export interface NewsServiceOptions {
+  pollIntervalMs?: number;
+}
+
+export type NewsQueryListener = (state: NewsQueryState) => void;
+
+const MAX_ARTICLES = 500;
+const DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1000;
+const DEFAULT_GLOBAL_QUERY: NewsQuery = { feed: "latest", limit: MAX_ARTICLES };
+const FEEDS = new Set<NewsFeed>(["latest", "top", "breaking", "ticker", "sector", "topic"]);
+
+function normalizeTicker(ticker: string | undefined): string {
+  return ticker ? normalizeSymbol(ticker) : "";
+}
+
+function normalizeCategory(category: string): string {
+  return category.trim().toLowerCase();
+}
+
+function normalizeFeed(query: NewsQuery): NewsFeed {
+  if (query.feed && FEEDS.has(query.feed)) return query.feed;
+  return query.scope === "ticker" ? "ticker" : "latest";
+}
+
+function normalizeStringList(values: string[] | undefined): string[] | undefined {
+  const normalized = [...new Set((values ?? []).map(normalizeCategory).filter(Boolean))].sort();
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+export function buildNewsQueryKey(query: NewsQuery): string {
+  const feed = normalizeFeed(query);
+  const ticker = normalizeTicker(query.ticker);
+  const exchange = canonicalExchange(query.exchange);
+  const topics = normalizeStringList(query.topics ?? query.categories) ?? [];
+  const sectors = normalizeStringList(query.sectors) ?? [];
+  const sources = normalizeStringList(query.sources) ?? [];
+  const excludeSources = normalizeStringList(query.excludeSources) ?? [];
+  const tickerRelations = normalizeStringList(query.tickerRelations) ?? [];
+  return [
+    feed,
+    ticker,
+    exchange,
+    query.tickerTier ?? "",
+    query.limit ?? MAX_ARTICLES,
+    topics.join(","),
+    sectors.join(","),
+    sources.join(","),
+    excludeSources.join(","),
+    tickerRelations.join(","),
+    query.sentiment ?? "",
+    query.minImportance ?? "",
+    query.minUrgency ?? "",
+    query.breaking == null ? "" : String(query.breaking),
+    query.since?.toISOString() ?? "",
+    query.until?.toISOString() ?? "",
+    query.cursor ?? "",
+  ].join("|");
+}
+
+function normalizeQuery(query: NewsQuery): NewsQuery {
+  const feed = normalizeFeed(query);
+  const topics = normalizeStringList(query.topics ?? query.categories);
+  const sectors = normalizeStringList(query.sectors);
+  return {
+    ...query,
+    feed,
+    scope: feed === "ticker" ? "ticker" : "global",
+    ticker: query.ticker ? normalizeTicker(query.ticker) : undefined,
+    exchange: query.exchange ? canonicalExchange(query.exchange) : undefined,
+    tickerTier: query.tickerTier ?? (feed === "ticker" ? "primary" : undefined),
+    topics,
+    categories: topics,
+    sectors,
+    sources: normalizeStringList(query.sources),
+    excludeSources: normalizeStringList(query.excludeSources),
+    tickerRelations: normalizeStringList(query.tickerRelations),
+    limit: Math.max(1, Math.min(MAX_ARTICLES, query.limit ?? MAX_ARTICLES)),
+  };
+}
+
+function createIdleState(): NewsQueryState {
+  return {
+    phase: "idle",
+    articles: [],
+    error: null,
+    updatedAt: null,
+    sourceIds: [],
+  };
+}
+
+function articleKey(item: NewsArticle): string {
+  const url = item.url.trim().toLowerCase().replace(/#.*$/, "").replace(/\/$/, "");
+  return url || `id:${item.id}`;
+}
+
+function sortByPublishedAt(items: NewsArticle[]): NewsArticle[] {
+  return [...items].sort((a, b) => b.publishedAt.getTime() - a.publishedAt.getTime());
+}
+
+function dedupeArticles(items: NewsArticle[]): NewsArticle[] {
+  const byKey = new Map<string, NewsArticle>();
+  for (const item of items) {
+    const key = articleKey(item);
+    const existing = byKey.get(key);
+    if (!existing) {
+      byKey.set(key, item);
+      continue;
+    }
+    if (
+      item.importance > existing.importance ||
+      (item.importance === existing.importance && item.publishedAt > existing.publishedAt)
+    ) {
+      byKey.set(key, { ...existing, ...item });
+    }
+  }
+  return sortByPublishedAt([...byKey.values()]).slice(0, MAX_ARTICLES);
+}
+
+function filterArticlesForQuery(items: NewsArticle[], query: NewsQuery): NewsArticle[] {
+  let filtered = items;
+  if (query.since) {
+    const sinceMs = query.since.getTime();
+    filtered = filtered.filter((item) => item.publishedAt.getTime() > sinceMs);
+  }
+  const topics = query.topics ?? query.categories;
+  if (topics && topics.length > 0) {
+    const topicSet = new Set(topics.map(normalizeCategory));
+    filtered = filtered.filter((item) => (
+      [item.topic, ...item.topics, ...item.categories].some((topic) => topicSet.has(normalizeCategory(topic)))
+    ));
+  }
+  if (query.sectors && query.sectors.length > 0) {
+    const sectorSet = new Set(query.sectors.map(normalizeCategory));
+    filtered = filtered.filter((item) => (
+      [...item.sectors, ...item.categories].some((sector) => sectorSet.has(normalizeCategory(sector)))
+    ));
+  }
+  if (query.sentiment) {
+    filtered = filtered.filter((item) => item.sentiment === query.sentiment);
+  }
+  if (query.minImportance != null) {
+    filtered = filtered.filter((item) => item.scores.importance >= query.minImportance!);
+  }
+  if (query.minUrgency != null) {
+    filtered = filtered.filter((item) => item.scores.urgency >= query.minUrgency!);
+  }
+  if (query.breaking != null) {
+    filtered = filtered.filter((item) => item.isBreaking === query.breaking);
+  }
+  return filtered.slice(0, query.limit ?? MAX_ARTICLES);
+}
+
+interface SourceFetchResult {
+  articles: NewsArticle[];
+  sourceIds: string[];
+}
+
+function newsCapabilityPriority(source: NewsCapability): number {
+  return source.priority ?? 1000;
+}
+
+function newsCapabilitySourceId(source: NewsCapability): string {
+  return source.sourceId ?? source.id;
+}
+
+export class NewsService {
+  private readonly sources = new Map<string, NewsCapability>();
+  private readonly listeners = new Set<() => void>();
+  private readonly queryStates = new Map<string, NewsQueryState>();
+  private readonly queryByKey = new Map<string, NewsQuery>();
+  private readonly watchedQueries = new Map<string, { query: NewsQuery; refs: number }>();
+  private readonly inFlight = new Map<string, Promise<NewsQueryState>>();
+  private articles: NewsArticle[] = [];
+  private version = 0;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private readonly pollIntervalMs: number;
+
+  constructor(options: NewsServiceOptions = {}) {
+    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  }
+
+  register(source: NewsCapability): () => void {
+    this.sources.set(source.id, source);
+    this.seedCachedSource(source);
+    if (this.pollTimer !== null) {
+      void this.pollActiveQueries();
+    }
+    return () => this.unregister(source.id);
+  }
+
+  unregister(sourceId: string): void {
+    this.sources.delete(sourceId);
+  }
+
+  start(): void {
+    if (this.pollTimer !== null) return;
+    this.pollTimer = setInterval(() => void this.pollActiveQueries(), this.pollIntervalMs);
+  }
+
+  stop(): void {
+    if (this.pollTimer !== null) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  watchQuery(query: NewsQuery, listener: NewsQueryListener): () => void {
+    const normalized = normalizeQuery(query);
+    const key = buildNewsQueryKey(normalized);
+    const currentWatch = this.watchedQueries.get(key);
+    this.watchedQueries.set(key, {
+      query: normalized,
+      refs: (currentWatch?.refs ?? 0) + 1,
+    });
+
+    const emit = () => listener(this.queryStates.get(key) ?? createIdleState());
+    const unsubscribe = this.subscribe(emit);
+    emit();
+    void this.refreshQuery(normalized, false, { track: false });
+
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      unsubscribe();
+      const watch = this.watchedQueries.get(key);
+      if (!watch) return;
+      if (watch.refs <= 1) {
+        this.watchedQueries.delete(key);
+      } else {
+        this.watchedQueries.set(key, { query: watch.query, refs: watch.refs - 1 });
+      }
+    };
+  }
+
+  getVersion(): number {
+    return this.version;
+  }
+
+  private notify(): void {
+    this.version++;
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+
+  getQueryState(query: NewsQuery): NewsQueryState {
+    const normalized = normalizeQuery(query);
+    const key = buildNewsQueryKey(normalized);
+    this.queryByKey.set(key, normalized);
+    return this.queryStates.get(key) ?? createIdleState();
+  }
+
+  async load(query: NewsQuery): Promise<NewsQueryState> {
+    return this.refreshQuery(normalizeQuery(query), true);
+  }
+
+  async poll(query: NewsQuery = DEFAULT_GLOBAL_QUERY): Promise<void> {
+    await this.refreshQuery(normalizeQuery(query), false);
+  }
+
+  private async pollActiveQueries(): Promise<void> {
+    const queries = new Map<string, NewsQuery>();
+    for (const query of this.queryByKey.values()) {
+      queries.set(buildNewsQueryKey(query), query);
+    }
+    for (const [key, watch] of this.watchedQueries) {
+      queries.set(key, watch.query);
+    }
+    if (queries.size === 0) return;
+    await Promise.allSettled([...queries.values()].map((query) => this.refreshQuery(query, false, { track: false })));
+  }
+
+  private async refreshQuery(
+    query: NewsQuery,
+    showLoading: boolean,
+    options: { track?: boolean } = {},
+  ): Promise<NewsQueryState> {
+    const key = buildNewsQueryKey(query);
+    if (options.track !== false) {
+      this.queryByKey.set(key, query);
+    }
+    const existingFlight = this.inFlight.get(key);
+    if (existingFlight) return existingFlight;
+
+    const current = this.queryStates.get(key) ?? createIdleState();
+    if (showLoading) {
+      this.queryStates.set(key, {
+        ...current,
+        phase: current.articles.length > 0 ? "refreshing" : "loading",
+        error: null,
+      });
+      this.notify();
+    }
+
+    const promise = (async () => {
+      try {
+        const result = await this.fetchFromSources(query);
+        const articles = filterArticlesForQuery(dedupeArticles(result.articles), query);
+        const state: NewsQueryState = {
+          phase: "ready",
+          articles,
+          error: null,
+          updatedAt: Date.now(),
+          sourceIds: result.sourceIds,
+        };
+        this.queryStates.set(key, state);
+        this.rebuildArticlePool();
+        this.notify();
+        return state;
+      } catch (error) {
+        const state: NewsQueryState = {
+          ...current,
+          phase: "error",
+          error: error instanceof Error ? error.message : String(error),
+        };
+        this.queryStates.set(key, state);
+        this.notify();
+        return state;
+      } finally {
+        this.inFlight.delete(key);
+      }
+    })();
+
+    this.inFlight.set(key, promise);
+    return promise;
+  }
+
+  private enabledSources(query: NewsQuery): NewsCapability[] {
+    return [...this.sources.values()]
+      .filter((source) => source.isEnabled?.() !== false)
+      .filter((source) => source.provider.supports?.(query) ?? true)
+      .sort((a, b) => newsCapabilityPriority(a) - newsCapabilityPriority(b));
+  }
+
+  private async fetchFromSources(query: NewsQuery): Promise<SourceFetchResult> {
+    const sources = this.enabledSources(query);
+    if (normalizeFeed(query) === "ticker") {
+      return this.fetchTickerNews(query, sources);
+    }
+    return this.fetchMergedNews(query, sources);
+  }
+
+  private async fetchTickerNews(query: NewsQuery, sources: NewsCapability[]): Promise<SourceFetchResult> {
+    let firstEmpty: SourceFetchResult | null = null;
+    for (const source of sources) {
+      try {
+        const articles = await source.provider.fetchNews(query);
+        const result = { articles, sourceIds: [newsCapabilitySourceId(source)] };
+        if (articles.length > 0) return result;
+        firstEmpty ??= result;
+      } catch {
+        // Continue to lower-priority sources.
+      }
+    }
+    return firstEmpty ?? { articles: [], sourceIds: [] };
+  }
+
+  private async fetchMergedNews(query: NewsQuery, sources: NewsCapability[]): Promise<SourceFetchResult> {
+    const settled = await Promise.allSettled(
+      sources.map(async (source) => ({
+        source,
+        articles: await source.provider.fetchNews(query),
+      })),
+    );
+    const articles: NewsArticle[] = [];
+    const sourceIds: string[] = [];
+    for (const result of settled) {
+      if (result.status !== "fulfilled") continue;
+      articles.push(...result.value.articles);
+      sourceIds.push(newsCapabilitySourceId(result.value.source));
+    }
+    return { articles, sourceIds };
+  }
+
+  private seedCachedSource(source: NewsCapability): void {
+    const news = source.provider;
+    const queries = [...this.queryByKey.values()];
+    if (queries.length === 0) queries.push(DEFAULT_GLOBAL_QUERY);
+
+    let changed = false;
+    for (const query of queries) {
+      if (source.isEnabled?.() === false || news.supports?.(query) === false) continue;
+      const cached = news.getCachedNews?.(query) ?? [];
+      if (cached.length === 0) continue;
+      const key = buildNewsQueryKey(query);
+      const current = this.queryStates.get(key) ?? createIdleState();
+      this.queryStates.set(key, {
+        phase: "ready",
+        articles: filterArticlesForQuery(dedupeArticles([...current.articles, ...cached]), query),
+        error: null,
+        updatedAt: Date.now(),
+        sourceIds: [...new Set([...current.sourceIds, newsCapabilitySourceId(source)])],
+      });
+      changed = true;
+    }
+    if (changed) {
+      this.rebuildArticlePool();
+      this.notify();
+    }
+  }
+
+  private rebuildArticlePool(): void {
+    this.articles = dedupeArticles([...this.queryStates.values()].flatMap((state) => state.articles));
+  }
+
+  getTopStories(count = 20): NewsArticle[] {
+    return [...this.articles]
+      .sort((a, b) => b.importance - a.importance)
+      .slice(0, count);
+  }
+
+  getFirehose(since?: Date, count = 100): NewsArticle[] {
+    let items = this.articles;
+    if (since) {
+      const sinceMs = since.getTime();
+      items = items.filter((item) => item.publishedAt.getTime() > sinceMs);
+    }
+    // articles is already sorted by publishedAt descending
+    return items.slice(0, count);
+  }
+
+  getBySector(sector: string, count = 50): NewsArticle[] {
+    const normalizedSector = normalizeCategory(sector);
+    return this.articles
+      .filter((item) => [...item.sectors, ...item.categories].some((category) => normalizeCategory(category) === normalizedSector))
+      .slice(0, count);
+  }
+
+  getBreaking(count = 20): NewsArticle[] {
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    return this.articles
+      .filter(
+        (item) =>
+          item.isBreaking ||
+          (item.publishedAt.getTime() >= oneHourAgo && item.importance >= 70),
+      )
+      .slice(0, count);
+  }
+}
+
+export type NewsAggregatorOptions = NewsServiceOptions;
+export class NewsAggregator extends NewsService {}

package/src/news/hooks.ts

@@ -0,0 +1,39 @@
+import { useEffect, useSyncExternalStore } from "react";
+import { buildNewsQueryKey, type NewsService } from "./aggregator";
+import type { NewsQuery, NewsQueryState } from "./types";
+
+let sharedService: NewsService | null = null;
+
+export function setSharedNewsService(service: NewsService | null): void {
+  sharedService = service;
+}
+
+function idleState(): NewsQueryState {
+  return {
+    phase: "idle",
+    articles: [],
+    error: null,
+    updatedAt: null,
+    sourceIds: [],
+  };
+}
+
+function useNewsServiceVersion(): number {
+  if (!sharedService) return 0;
+  return useSyncExternalStore(
+    (cb) => sharedService!.subscribe(cb),
+    () => sharedService!.getVersion(),
+  );
+}
+
+export function useNewsArticles(query: NewsQuery | null | undefined): NewsQueryState {
+  const key = query ? buildNewsQueryKey(query) : null;
+  useNewsServiceVersion();
+
+  useEffect(() => {
+    if (!query || !sharedService) return;
+    void sharedService.load(query);
+  }, [key]);
+
+  return query && sharedService ? sharedService.getQueryState(query) : idleState();
+}

package/src/news/ticker-symbols.ts

@@ -0,0 +1,21 @@
+export function newsDisplayTickerSymbol(value: string | null | undefined): string | null {
+  const normalized = value?.trim().toUpperCase();
+  if (!normalized) return null;
+  return normalized.split(":")[0] || null;
+}
+
+export function collectNewsDisplayTickers(
+  values: readonly (string | null | undefined)[],
+): string[] {
+  const seen = new Set<string>();
+  const tickers: string[] = [];
+
+  for (const value of values) {
+    const symbol = newsDisplayTickerSymbol(value);
+    if (!symbol || seen.has(symbol)) continue;
+    seen.add(symbol);
+    tickers.push(symbol);
+  }
+
+  return tickers;
+}

package/src/news/types.ts

@@ -0,0 +1,77 @@
+export type NewsQueryScope = "global" | "ticker";
+export type NewsFeed = "latest" | "top" | "breaking" | "ticker" | "sector" | "topic";
+export type NewsSentiment = "positive" | "neutral" | "negative";
+
+export interface NewsScores {
+  importance: number;
+  urgency: number;
+  marketImpact: number;
+  novelty: number;
+  confidence: number;
+}
+
+export interface NewsStoryItem {
+  id: string;
+  sourceKey: string;
+  sourceName: string;
+  title: string;
+  summary?: string;
+  url: string;
+  publishedAt: Date;
+  hasArticleText?: boolean;
+}
+
+export interface NewsArticle {
+  id: string;
+  title: string;
+  url: string;
+  source: string;
+  publishedAt: Date;
+  summary?: string;
+  imageUrl?: string;
+  topic: string;
+  topics: string[];
+  sectors: string[];
+  categories: string[];
+  tickers: string[];
+  sentiment?: NewsSentiment;
+  scores: NewsScores;
+  isBreaking: boolean;
+  isDeveloping: boolean;
+  items?: NewsStoryItem[];
+
+  // Compatibility aliases for RSS/Yahoo panes and existing table columns.
+  importance: number;
+}
+
+export interface NewsQuery {
+  feed?: NewsFeed;
+  scope?: NewsQueryScope;
+  ticker?: string;
+  exchange?: string;
+  tickerTier?: "primary" | "related" | "any";
+  tickerRelations?: string[];
+  topics?: string[];
+  sectors?: string[];
+  sources?: string[];
+  excludeSources?: string[];
+  sentiment?: NewsSentiment;
+  minImportance?: number;
+  minUrgency?: number;
+  breaking?: boolean;
+  limit?: number;
+  categories?: string[];
+  since?: Date;
+  until?: Date;
+  cursor?: string;
+}
+
+export type NewsQueryPhase = "idle" | "loading" | "ready" | "refreshing" | "error";
+
+export interface NewsQueryState {
+  phase: NewsQueryPhase;
+  articles: NewsArticle[];
+  error: string | null;
+  updatedAt: number | null;
+  sourceIds: string[];
+}

package/src/notifications/app-notifier.ts

@@ -1,10 +1,13 @@
-import { spawn } from "child_process";
 import type { AppNotificationRequest, AppNotificationType } from "../types/plugin";
 import { debugLog } from "../utils/debug-log";
 
 const DEFAULT_NOTIFICATION_TITLE = "Gloomberb";
 const notificationLog = debugLog.createLogger("notifications");
 
+function getRuntimePlatform(): NodeJS.Platform {
+  return typeof process !== "undefined" ? process.platform : "linux";
+}
+
 export interface DesktopNotificationCommand {
   command: string;
   args: string[];
@@ -66,7 +69,7 @@ function buildWindowsBody(notification: AppNotificationRequest): string {
 
 export function buildDesktopNotificationCommand(
   notification: AppNotificationRequest,
-  platform: NodeJS.Platform = process.platform,
+  platform: NodeJS.Platform = getRuntimePlatform(),
 ): DesktopNotificationCommand | null {
   const title = notification.title?.trim() || DEFAULT_NOTIFICATION_TITLE;
   const body = notification.body.trim();
@@ -131,16 +134,24 @@ function defaultDesktopNotificationRunner(
   args: string[],
   handlers?: { onError?: (error: NodeJS.ErrnoException) => void },
 ): void {
-  const child = spawn(command, args, { detached: true, stdio: "ignore" });
-  child.once("error", (error) => {
-    handlers?.onError?.(error);
-  });
-  child.unref();
+  if (typeof Bun !== "undefined" && typeof Bun.spawn === "function") {
+    try {
+      const child = Bun.spawn([command, ...args], { stdio: ["ignore", "ignore", "ignore"] });
+      child.unref();
+    } catch (error) {
+      handlers?.onError?.(error as NodeJS.ErrnoException);
+    }
+    return;
+  }
+
+  handlers?.onError?.(Object.assign(new Error("Desktop notifications require a native process host."), {
+    code: "ENOSYS",
+  }) as NodeJS.ErrnoException);
 }
 
 export function buildSoundCommand(
   soundName: string,
-  platform: NodeJS.Platform = process.platform,
+  platform: NodeJS.Platform = getRuntimePlatform(),
 ): DesktopNotificationCommand | null {
   if (platform === "darwin") {
     return {
@@ -176,7 +187,7 @@ export function createDesktopNotifier(
     runner?: DesktopNotificationRunner;
   } = {},
 ): DesktopNotificationSink {
-  const platform = options.platform ?? process.platform;
+  const platform = options.platform ?? getRuntimePlatform();
   const runner = options.runner ?? { run: defaultDesktopNotificationRunner };
   let disabledCommand: string | null = null;
 
@@ -219,7 +230,7 @@ export function createDesktopNotifier(
 export function createAppNotifier({
   isAppActive,
   renderToast,
-  desktop = createDesktopNotifier(),
+  desktop = typeof Bun !== "undefined" ? createDesktopNotifier() : null,
 }: CreateAppNotifierOptions): AppNotifier {
   return {
     notify(notification) {

package/src/pane-settings.test.ts

@@ -10,8 +10,6 @@ describe("pane settings helpers", () => {
 
     expect(portfolioPane?.settings).toMatchObject({
       collectionScope: "all",
-      hideTabs: false,
-      lockedCollectionId: "main",
     });
     expect(portfolioPane?.settings?.columnIds).toEqual(DEFAULT_PORTFOLIO_COLUMN_IDS);
     expect(detailPane?.settings).toEqual({