gloomberb 0.5.0 → 0.6.0

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

@@ -0,0 +1,296 @@
+import { useCallback, useEffect, useMemo, type ReactNode } from "react";
+import { TextAttributes } from "../../../ui";
+import {
+  DataTableStackView,
+  TickerBadgeList,
+  type DataTableCell,
+  type DataTableColumn,
+} from "../../../components";
+import type { MarketNewsItem } from "../../../types/news-source";
+import { colors } from "../../../theme/colors";
+import { collectNewsDisplayTickers } from "../../../news/ticker-symbols";
+import { useInlineTickers } from "../../../state/use-inline-tickers";
+
+export type NewsColumnId = "rank" | "time" | "source" | "title" | "tickers" | "categories" | "importance";
+
+export interface NewsSortPreference {
+  columnId: NewsColumnId;
+  direction: "asc" | "desc";
+}
+
+type NewsTableColumn = DataTableColumn & { id: NewsColumnId };
+
+interface NewsArticleStackBaseProps {
+  articles: MarketNewsItem[];
+  focused: boolean;
+  width: number;
+  readArticleIds?: ReadonlySet<string>;
+  selectedArticleId: string | null;
+  setSelectedArticleId: (articleId: string | null) => void;
+  sortPreference: NewsSortPreference;
+  setSortPreference: (preference: NewsSortPreference) => void;
+  onOpenArticle: (article: MarketNewsItem) => void;
+  onArticleRead?: (articleId: string) => void;
+  columns: NewsColumnId[];
+  emptyContent?: ReactNode;
+  emptyStateTitle: string;
+  emptyStateHint?: string;
+  titleForArticle?: (article: MarketNewsItem) => string;
+}
+
+export function formatRelativeTime(date: Date): string {
+  const ms = Date.now() - date.getTime();
+  if (ms < 60_000) return "<1m";
+  const min = Math.floor(ms / 60_000);
+  if (min < 60) return `${min}m`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h`;
+  const days = Math.floor(hr / 24);
+  return `${days}d`;
+}
+
+function compareText(a: string, b: string): number {
+  return a.localeCompare(b, "en-US", { sensitivity: "base" });
+}
+
+function compareArticle(a: MarketNewsItem, b: MarketNewsItem, columnId: NewsColumnId): number {
+  switch (columnId) {
+    case "rank":
+    case "importance":
+      return a.importance - b.importance;
+    case "time":
+      return a.publishedAt.getTime() - b.publishedAt.getTime();
+    case "source":
+      return compareText(a.source, b.source);
+    case "title":
+      return compareText(a.title, b.title);
+    case "tickers":
+      return compareText(
+        collectNewsDisplayTickers(a.tickers).join(" "),
+        collectNewsDisplayTickers(b.tickers).join(" "),
+      );
+    case "categories":
+      return compareText(a.categories.join(" "), b.categories.join(" "));
+  }
+}
+
+export function sortNewsArticles(
+  articles: MarketNewsItem[],
+  preference: NewsSortPreference,
+): MarketNewsItem[] {
+  const direction = preference.direction === "asc" ? 1 : -1;
+  return [...articles].sort((a, b) => {
+    const primary = compareArticle(a, b, preference.columnId) * direction;
+    if (primary !== 0) return primary;
+    return b.publishedAt.getTime() - a.publishedAt.getTime();
+  });
+}
+
+function nextSortPreference(current: NewsSortPreference, columnId: NewsColumnId): NewsSortPreference {
+  if (current.columnId === columnId) {
+    return {
+      columnId,
+      direction: current.direction === "asc" ? "desc" : "asc",
+    };
+  }
+  return {
+    columnId,
+    direction: columnId === "title" || columnId === "source" || columnId === "categories" ? "asc" : "desc",
+  };
+}
+
+function buildColumns(width: number, columnIds: NewsColumnId[]): NewsTableColumn[] {
+  const fixedWidths: Record<Exclude<NewsColumnId, "title">, number> = {
+    rank: 4,
+    time: 4,
+    source: 10,
+    tickers: 24,
+    categories: 10,
+    importance: 5,
+  };
+  const labels: Record<NewsColumnId, string> = {
+    rank: "#",
+    time: "Time",
+    source: "Source",
+    title: "Headline",
+    tickers: "Tickers",
+    categories: "Category",
+    importance: "Score",
+  };
+
+  const fixedTotal = columnIds
+    .filter((id) => id !== "title")
+    .reduce((sum, id) => sum + fixedWidths[id as Exclude<NewsColumnId, "title">] + 1, 0);
+  const tablePadding = 2;
+  const titleWidth = Math.max(16, width - fixedTotal - tablePadding - 1);
+
+  return columnIds.map((id) => ({
+    id,
+    label: labels[id],
+    width: id === "title" ? titleWidth : fixedWidths[id],
+    align: id === "rank" || id === "importance" ? "right" : "left",
+    flexGrow: id === "title" ? 1 : undefined,
+  }));
+}
+
+interface NewsArticleStackViewProps extends NewsArticleStackBaseProps {
+  detailOpen: boolean;
+  onBack: () => void;
+  detailContent: ReactNode;
+  detailTitle?: string;
+  rootBefore?: ReactNode;
+  rootHeight?: number;
+  onRootKeyDown?: (event: {
+    name?: string;
+    preventDefault?: () => void;
+    stopPropagation?: () => void;
+  }) => boolean | void;
+}
+
+export function NewsArticleStackView({
+  articles,
+  focused,
+  width,
+  readArticleIds,
+  rootHeight,
+  selectedArticleId,
+  setSelectedArticleId,
+  sortPreference,
+  setSortPreference,
+  onOpenArticle,
+  onArticleRead,
+  detailOpen,
+  onBack,
+  detailContent,
+  detailTitle,
+  rootBefore,
+  onRootKeyDown,
+  columns: columnIds,
+  emptyContent,
+  emptyStateTitle,
+  emptyStateHint,
+  titleForArticle,
+}: NewsArticleStackViewProps) {
+  const sortedArticles = useMemo(
+    () => sortNewsArticles(articles, sortPreference),
+    [articles, sortPreference],
+  );
+  const tableTickerTexts = useMemo(() => {
+    const seen = new Set<string>();
+    const texts: string[] = [];
+    for (const article of sortedArticles) {
+      for (const symbol of collectNewsDisplayTickers(article.tickers)) {
+        if (seen.has(symbol)) continue;
+        seen.add(symbol);
+        texts.push(`$${symbol}`);
+      }
+    }
+    return texts;
+  }, [sortedArticles]);
+  const { catalog: tickerCatalog, openTicker } = useInlineTickers(tableTickerTexts);
+  const columns = useMemo(() => buildColumns(width, columnIds), [columnIds, width]);
+  const selectedIdx = sortedArticles.findIndex((article) => article.id === selectedArticleId);
+  const activeIdx = selectedIdx >= 0 ? selectedIdx : sortedArticles.length > 0 ? 0 : -1;
+
+  const selectIndex = useCallback((index: number) => {
+    setSelectedArticleId(sortedArticles[index]?.id ?? null);
+  }, [setSelectedArticleId, sortedArticles]);
+
+  const openArticle = useCallback((article: MarketNewsItem) => {
+    onArticleRead?.(article.id);
+    onOpenArticle(article);
+  }, [onArticleRead, onOpenArticle]);
+
+  const openIndex = useCallback((index: number) => {
+    const article = sortedArticles[index];
+    if (article) openArticle(article);
+  }, [openArticle, sortedArticles]);
+
+  useEffect(() => {
+    if (sortedArticles.length === 0) {
+      if (selectedArticleId !== null) setSelectedArticleId(null);
+      return;
+    }
+    if (selectedArticleId === null || selectedIdx < 0) {
+      setSelectedArticleId(sortedArticles[0]!.id);
+    }
+  }, [selectedArticleId, selectedIdx, setSelectedArticleId, sortedArticles]);
+
+  const renderCell = useCallback((
+    item: MarketNewsItem,
+    column: NewsTableColumn,
+    index: number,
+    rowState: { selected: boolean },
+  ): DataTableCell => {
+    const selectedColor = rowState.selected ? colors.selectedText : undefined;
+    switch (column.id) {
+      case "rank":
+        return { text: String(index + 1), color: selectedColor ?? colors.textDim };
+      case "time":
+        return { text: formatRelativeTime(item.publishedAt), color: selectedColor ?? colors.textDim };
+      case "source":
+        return { text: item.source, color: selectedColor ?? colors.textMuted };
+      case "title":
+        return {
+          text: titleForArticle?.(item) ?? item.title,
+          color: selectedColor ?? colors.text,
+          attributes: readArticleIds?.has(item.id)
+            ? TextAttributes.NONE
+            : TextAttributes.BOLD,
+        };
+      case "tickers": {
+        const tickers = collectNewsDisplayTickers(item.tickers);
+        return {
+          text: tickers.join(" "),
+          content: (
+            <TickerBadgeList
+              symbols={tickers}
+              width={column.width}
+              catalog={tickerCatalog}
+              fallbackColor={selectedColor ?? colors.textBright}
+              openTicker={openTicker}
+            />
+          ),
+          color: selectedColor ?? colors.textBright,
+        };
+      }
+      case "categories":
+        return { text: item.categories[0] ?? "—", color: selectedColor ?? colors.textDim };
+      case "importance":
+        return {
+          text: String(item.importance),
+          color: selectedColor ?? (item.importance >= 80 ? colors.positive : colors.textDim),
+        };
+    }
+  }, [openTicker, readArticleIds, tickerCatalog, titleForArticle]);
+
+  return (
+    <DataTableStackView<MarketNewsItem, NewsTableColumn>
+      focused={focused}
+      detailOpen={detailOpen}
+      onBack={onBack}
+      detailContent={detailContent}
+      detailTitle={detailTitle}
+      selectedIndex={activeIdx}
+      onSelectIndex={selectIndex}
+      onActivateIndex={openIndex}
+      rootBefore={rootBefore}
+      rootHeight={rootHeight}
+      onRootKeyDown={onRootKeyDown}
+      columns={columns}
+      items={sortedArticles}
+      sortColumnId={sortPreference.columnId}
+      sortDirection={sortPreference.direction}
+      onHeaderClick={(columnId) => setSortPreference(nextSortPreference(sortPreference, columnId as NewsColumnId))}
+      getItemKey={(item) => item.id}
+      isSelected={(item, index) => item.id === selectedArticleId || (selectedArticleId === null && index === 0)}
+      onSelect={(article) => setSelectedArticleId(article.id)}
+      onActivate={openArticle}
+      renderCell={renderCell}
+      emptyContent={emptyContent}
+      emptyStateTitle={emptyStateTitle}
+      emptyStateHint={emptyStateHint}
+      showHorizontalScrollbar={false}
+    />
+  );
+}

package/src/plugins/builtin/news-wire/persisted-articles.ts

@@ -0,0 +1,92 @@
+import { useEffect, useMemo } from "react";
+import type { MarketNewsItem, NewsStoryItem } from "../../../types/news-source";
+import { usePluginPaneState } from "../../plugin-runtime";
+
+const MAX_PERSISTED_ARTICLES = 200;
+const EMPTY_PERSISTED_ARTICLES: PersistedNewsArticle[] = [];
+
+interface PersistedNewsStoryItem extends Omit<NewsStoryItem, "publishedAt"> {
+  publishedAt: string;
+}
+
+interface PersistedNewsArticle extends Omit<MarketNewsItem, "publishedAt" | "items"> {
+  publishedAt: string;
+  items?: PersistedNewsStoryItem[];
+}
+
+function articleDate(value: Date | string): Date | null {
+  const date = value instanceof Date ? value : new Date(String(value));
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function serializeStoryItem(item: NewsStoryItem): PersistedNewsStoryItem | null {
+  const publishedAt = articleDate(item.publishedAt);
+  if (!publishedAt) return null;
+  return {
+    ...item,
+    publishedAt: publishedAt.toISOString(),
+  };
+}
+
+function serializeArticle(article: MarketNewsItem): PersistedNewsArticle | null {
+  const publishedAt = articleDate(article.publishedAt);
+  if (!publishedAt) return null;
+  return {
+    ...article,
+    publishedAt: publishedAt.toISOString(),
+    items: article.items
+      ?.map(serializeStoryItem)
+      .filter((item): item is PersistedNewsStoryItem => !!item),
+  };
+}
+
+function restoreStoryItem(item: PersistedNewsStoryItem): NewsStoryItem | null {
+  const publishedAt = articleDate(item.publishedAt);
+  if (!publishedAt) return null;
+  return {
+    ...item,
+    publishedAt,
+  };
+}
+
+function restoreArticle(article: PersistedNewsArticle): MarketNewsItem | null {
+  const publishedAt = articleDate(article.publishedAt);
+  if (!publishedAt) return null;
+  return {
+    ...article,
+    publishedAt,
+    items: article.items
+      ?.map(restoreStoryItem)
+      .filter((item): item is NewsStoryItem => !!item),
+  };
+}
+
+function samePersistedArticles(left: PersistedNewsArticle[], right: PersistedNewsArticle[]): boolean {
+  if (left.length !== right.length) return false;
+  return left.every((article, index) => {
+    const other = right[index];
+    return other?.id === article.id && other.publishedAt === article.publishedAt;
+  });
+}
+
+export function usePersistedNewsArticles(key: string, articles: MarketNewsItem[]): MarketNewsItem[] {
+  const [persistedArticles, setPersistedArticles] = usePluginPaneState<PersistedNewsArticle[]>(
+    key,
+    EMPTY_PERSISTED_ARTICLES,
+  );
+  const restoredArticles = useMemo(
+    () => persistedArticles.map(restoreArticle).filter((article): article is MarketNewsItem => !!article),
+    [persistedArticles],
+  );
+
+  useEffect(() => {
+    if (articles.length === 0) return;
+    const next = articles
+      .slice(0, MAX_PERSISTED_ARTICLES)
+      .map(serializeArticle)
+      .filter((article): article is PersistedNewsArticle => !!article);
+    setPersistedArticles((current) => samePersistedArticles(current, next) ? current : next);
+  }, [articles, setPersistedArticles]);
+
+  return articles.length > 0 ? articles : restoredArticles;
+}

package/src/plugins/builtin/news-wire/read-state.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import {
+  MAX_READ_ARTICLE_IDS,
+  markNewsArticleRead,
+  normalizeNewsReadState,
+} from "./read-state";
+
+describe("news read state", () => {
+  test("marks opened articles as read with the most recent first", () => {
+    const state = markNewsArticleRead({ articleIds: ["old"] }, "new");
+
+    expect(state.articleIds).toEqual(["new", "old"]);
+  });
+
+  test("deduplicates existing read articles when reopened", () => {
+    const state = markNewsArticleRead({ articleIds: ["a", "b", "a"] }, "b");
+
+    expect(state.articleIds).toEqual(["b", "a"]);
+  });
+
+  test("keeps persisted read state bounded", () => {
+    const state = normalizeNewsReadState({
+      articleIds: Array.from({ length: MAX_READ_ARTICLE_IDS + 25 }, (_, index) => `id-${index}`),
+    });
+
+    expect(state.articleIds).toHaveLength(MAX_READ_ARTICLE_IDS);
+    expect(state.articleIds[0]).toBe("id-0");
+    expect(state.articleIds.at(-1)).toBe(`id-${MAX_READ_ARTICLE_IDS - 1}`);
+  });
+});

package/src/plugins/builtin/news-wire/read-state.ts

@@ -0,0 +1,76 @@
+import { useCallback, useMemo } from "react";
+import { usePluginState } from "../../plugin-runtime";
+
+export interface NewsReadState {
+  articleIds: string[];
+}
+
+export const NEWS_READ_STATE_SCHEMA_VERSION = 1;
+export const MAX_READ_ARTICLE_IDS = 2_000;
+
+const READ_STATE_KEY = "read-articles";
+const EMPTY_READ_STATE: NewsReadState = { articleIds: [] };
+
+function normalizeArticleId(articleId: string): string {
+  return articleId.trim();
+}
+
+function sameStringArray(left: string[], right: string[]): boolean {
+  if (left.length !== right.length) return false;
+  return left.every((value, index) => value === right[index]);
+}
+
+export function normalizeNewsReadState(state: NewsReadState): NewsReadState {
+  const seen = new Set<string>();
+  const articleIds: string[] = [];
+
+  for (const rawId of state.articleIds) {
+    if (typeof rawId !== "string") continue;
+    const articleId = normalizeArticleId(rawId);
+    if (!articleId || seen.has(articleId)) continue;
+    seen.add(articleId);
+    articleIds.push(articleId);
+    if (articleIds.length >= MAX_READ_ARTICLE_IDS) break;
+  }
+
+  return { articleIds };
+}
+
+export function markNewsArticleRead(
+  state: NewsReadState,
+  articleId: string,
+): NewsReadState {
+  const normalizedId = normalizeArticleId(articleId);
+  const current = normalizeNewsReadState(state).articleIds;
+  if (!normalizedId) {
+    return sameStringArray(current, state.articleIds) ? state : { articleIds: current };
+  }
+
+  const articleIds = [
+    normalizedId,
+    ...current.filter((currentId) => currentId !== normalizedId),
+  ].slice(0, MAX_READ_ARTICLE_IDS);
+
+  return sameStringArray(articleIds, state.articleIds) ? state : { articleIds };
+}
+
+export function useNewsReadState() {
+  const [readState, setReadState] = usePluginState<NewsReadState>(
+    READ_STATE_KEY,
+    EMPTY_READ_STATE,
+    { schemaVersion: NEWS_READ_STATE_SCHEMA_VERSION },
+  );
+  const normalizedReadState = useMemo(
+    () => normalizeNewsReadState(readState),
+    [readState],
+  );
+  const readArticleIds = useMemo(
+    () => new Set(normalizedReadState.articleIds),
+    [normalizedReadState],
+  );
+  const markArticleRead = useCallback((articleId: string) => {
+    setReadState((current) => markNewsArticleRead(current, articleId));
+  }, [setReadState]);
+
+  return { readArticleIds, markArticleRead };
+}

package/src/plugins/builtin/news-wire/rss-parser.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, test } from "bun:test";
+import { parseRssFeed, type RssFeedConfig } from "./rss-parser";
+
+const DEFAULT_CONFIG: RssFeedConfig = {
+  id: "test-feed",
+  url: "https://example.com/feed",
+  name: "Test Feed",
+  authority: 60,
+  enabled: true,
+};
+
+const RSS2_FIXTURE = `<?xml version="1.0"?>
+<rss version="2.0">
+<channel>
+  <title>Test Feed</title>
+  <item>
+    <title>Fed holds rates steady</title>
+    <link>https://example.com/fed-rates</link>
+    <pubDate>Thu, 10 Apr 2026 14:30:00 GMT</pubDate>
+    <description>&lt;p&gt;The Federal Reserve held rates steady at 4.25%.&lt;/p&gt;</description>
+    <category>Economy</category>
+  </item>
+  <item>
+    <title><![CDATA[NVIDIA beats Q1 estimates]]></title>
+    <link>https://example.com/nvda-q1</link>
+    <pubDate>Thu, 10 Apr 2026 10:00:00 GMT</pubDate>
+    <description>NVIDIA reported strong earnings.</description>
+  </item>
+  <item>
+    <title>Oil surges on OPEC cuts</title>
+    <link>https://example.com/oil-opec</link>
+    <pubDate>Thu, 10 Apr 2026 08:00:00 GMT</pubDate>
+  </item>
+</channel>
+</rss>`;
+
+const ATOM_FIXTURE = `<?xml version="1.0"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>Atom Feed</title>
+  <entry>
+    <title>Markets rally on trade deal</title>
+    <link href="https://example.com/trade-deal"/>
+    <published>2026-04-10T12:00:00Z</published>
+    <summary>Global markets surged on news of a trade agreement.</summary>
+  </entry>
+</feed>`;
+
+describe("parseRssFeed - RSS 2.0", () => {
+  test("returns 3 items from fixture", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items).toHaveLength(3);
+  });
+
+  test("extracts title correctly", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.title).toBe("Fed holds rates steady");
+  });
+
+  test("extracts url correctly", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.url).toBe("https://example.com/fed-rates");
+  });
+
+  test("parses pubDate", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.publishedAt).toBeInstanceOf(Date);
+    expect(items[0]!.publishedAt.getFullYear()).toBe(2026);
+  });
+
+  test("strips HTML from description", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.summary).not.toContain("<p>");
+    expect(items[0]!.summary).toContain("Federal Reserve");
+  });
+
+  test("decodes HTML entities in description", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.summary).not.toContain("&lt;");
+    expect(items[0]!.summary).not.toContain("&gt;");
+  });
+
+  test("handles CDATA in title", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items[1]!.title).toBe("NVIDIA beats Q1 estimates");
+  });
+
+  test("handles missing description (no crash, no summary)", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items[2]!.summary).toBeUndefined();
+    expect(items[2]!.title).toBe("Oil surges on OPEC cuts");
+  });
+
+  test("extracts category from <category> tag", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.categories).toContain("Economy");
+  });
+
+  test("assigns source from config name", () => {
+    const items = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    for (const item of items) {
+      expect(item.source).toBe("Test Feed");
+    }
+  });
+
+  test("generates stable IDs", () => {
+    const items1 = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    const items2 = parseRssFeed(RSS2_FIXTURE, DEFAULT_CONFIG);
+    expect(items1[0]!.id).toBe(items2[0]!.id);
+  });
+});
+
+describe("parseRssFeed - Atom", () => {
+  test("returns 1 entry from atom fixture", () => {
+    const items = parseRssFeed(ATOM_FIXTURE, DEFAULT_CONFIG);
+    expect(items).toHaveLength(1);
+  });
+
+  test("extracts title from atom entry", () => {
+    const items = parseRssFeed(ATOM_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.title).toBe("Markets rally on trade deal");
+  });
+
+  test("extracts href link from atom entry", () => {
+    const items = parseRssFeed(ATOM_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.url).toBe("https://example.com/trade-deal");
+  });
+
+  test("parses published date from atom entry", () => {
+    const items = parseRssFeed(ATOM_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.publishedAt).toBeInstanceOf(Date);
+    expect(items[0]!.publishedAt.getFullYear()).toBe(2026);
+    expect(items[0]!.publishedAt.getMonth()).toBe(3); // April = 3
+  });
+
+  test("extracts summary from atom entry", () => {
+    const items = parseRssFeed(ATOM_FIXTURE, DEFAULT_CONFIG);
+    expect(items[0]!.summary).toContain("trade agreement");
+  });
+});
+
+describe("parseRssFeed - edge cases", () => {
+  test("returns empty array for empty string", () => {
+    expect(parseRssFeed("", DEFAULT_CONFIG)).toHaveLength(0);
+  });
+
+  test("returns empty array for invalid XML", () => {
+    expect(parseRssFeed("not xml at all <<<", DEFAULT_CONFIG)).toHaveLength(0);
+  });
+
+  test("returns empty array for whitespace-only input", () => {
+    expect(parseRssFeed("   \n\t  ", DEFAULT_CONFIG)).toHaveLength(0);
+  });
+
+  test("truncates summary to 300 chars", () => {
+    const longDesc = "x".repeat(400);
+    const xml = `<rss version="2.0"><channel><item>
+      <title>Long item</title>
+      <link>https://example.com/long</link>
+      <pubDate>Thu, 10 Apr 2026 08:00:00 GMT</pubDate>
+      <description>${longDesc}</description>
+    </item></channel></rss>`;
+    const items = parseRssFeed(xml, DEFAULT_CONFIG);
+    expect(items).toHaveLength(1);
+    // 300 chars + ellipsis
+    expect(items[0]!.summary!.length).toBeLessThanOrEqual(301);
+    expect(items[0]!.summary!).toContain("…");
+  });
+
+  test("handles item with only a title (no link)", () => {
+    const xml = `<rss version="2.0"><channel><item>
+      <title>Titleonly item</title>
+    </item></channel></rss>`;
+    const items = parseRssFeed(xml, DEFAULT_CONFIG);
+    expect(items).toHaveLength(1);
+    expect(items[0]!.title).toBe("Titleonly item");
+  });
+
+  test("uses config category when no <category> tag present", () => {
+    const cfg: RssFeedConfig = { ...DEFAULT_CONFIG, category: "markets" };
+    const items = parseRssFeed(RSS2_FIXTURE, cfg);
+    // item[1] has no <category> tag
+    expect(items[1]!.categories).toContain("markets");
+  });
+});