gloomberb 0.4.1 → 0.5.0

package/src/utils/terminal-input-reset.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test";
+import { resetTerminalInputState, TERMINAL_MOUSE_RESET_SEQUENCE } from "./terminal-input-reset";
+
+describe("resetTerminalInputState", () => {
+  test("disables mouse tracking and exits raw mode before renderer startup", () => {
+    const writes: string[] = [];
+    const rawModeCalls: boolean[] = [];
+
+    resetTerminalInputState(
+      {
+        isTTY: true,
+        setRawMode(mode: boolean) {
+          rawModeCalls.push(mode);
+        },
+      },
+      {
+        isTTY: true,
+        write(chunk: string) {
+          writes.push(chunk);
+        },
+      },
+    );
+
+    expect(writes).toEqual([TERMINAL_MOUSE_RESET_SEQUENCE]);
+    expect(rawModeCalls).toEqual([false]);
+  });
+
+  test("does not write terminal escapes when stdout is not a tty", () => {
+    const writes: string[] = [];
+    const rawModeCalls: boolean[] = [];
+
+    resetTerminalInputState(
+      {
+        isTTY: true,
+        setRawMode(mode: boolean) {
+          rawModeCalls.push(mode);
+        },
+      },
+      {
+        isTTY: false,
+        write(chunk: string) {
+          writes.push(chunk);
+        },
+      },
+    );
+
+    expect(writes).toEqual([]);
+    expect(rawModeCalls).toEqual([false]);
+  });
+});

package/src/utils/terminal-input-reset.ts

@@ -0,0 +1,24 @@
+export const TERMINAL_MOUSE_RESET_SEQUENCE = "\x1B[?1016l\x1B[?1006l\x1B[?1005l\x1B[?1015l\x1B[?1003l\x1B[?1002l\x1B[?1000l";
+
+interface TerminalResetStdin {
+  isTTY?: boolean;
+  setRawMode?: (mode: boolean) => void;
+}
+
+interface TerminalResetStdout {
+  isTTY?: boolean;
+  write: (chunk: string) => unknown;
+}
+
+export function resetTerminalInputState(
+  stdin: TerminalResetStdin = process.stdin,
+  stdout: TerminalResetStdout = process.stdout,
+): void {
+  if (stdout.isTTY) {
+    stdout.write(TERMINAL_MOUSE_RESET_SEQUENCE);
+  }
+
+  if (stdin.isTTY !== false && typeof stdin.setRawMode === "function") {
+    stdin.setRawMode(false);
+  }
+}

package/src/utils/throttled-fetch.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test, mock, beforeEach, afterAll } from "bun:test";
+import { createThrottledFetch } from "./throttled-fetch";
+
+// Mock global fetch
+const originalFetch = globalThis.fetch;
+let fetchMock: ReturnType<typeof mock>;
+
+beforeEach(() => {
+  fetchMock = mock(() => Promise.resolve(new Response(JSON.stringify({ ok: true }), { status: 200 })));
+  globalThis.fetch = fetchMock as any;
+});
+
+describe("createThrottledFetch", () => {
+  test("passes through a simple request", async () => {
+    const client = createThrottledFetch();
+    const resp = await client.fetch("https://api.example.com/test");
+    expect(resp.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("merges default headers", async () => {
+    const client = createThrottledFetch({
+      defaultHeaders: { "X-Custom": "value" },
+    });
+    await client.fetch("https://api.example.com/test");
+    const callInit = fetchMock.mock.calls[0]![1] as RequestInit;
+    expect((callInit.headers as Record<string, string>)["X-Custom"]).toBe("value");
+  });
+
+  test("deduplicates concurrent GET requests to same URL", async () => {
+    let resolveFirst: (r: Response) => void;
+    const slowResponse = new Promise<Response>((resolve) => { resolveFirst = resolve; });
+    fetchMock = mock(() => slowResponse);
+    globalThis.fetch = fetchMock as any;
+
+    const client = createThrottledFetch();
+    const p1 = client.fetch("https://api.example.com/same");
+    const p2 = client.fetch("https://api.example.com/same");
+
+    resolveFirst!(new Response("ok", { status: 200 }));
+    const [r1, r2] = await Promise.all([p1, p2]);
+    expect(r1).not.toBe(r2);
+    expect(await r1.text()).toBe("ok");
+    expect(await r2.text()).toBe("ok");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("does not deduplicate different URLs", async () => {
+    const client = createThrottledFetch();
+    await Promise.all([
+      client.fetch("https://api.example.com/a"),
+      client.fetch("https://api.example.com/b"),
+    ]);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  test("retries on 429 with backoff", async () => {
+    let callCount = 0;
+    fetchMock = mock(() => {
+      callCount++;
+      if (callCount === 1) {
+        return Promise.resolve(new Response("rate limited", { status: 429 }));
+      }
+      return Promise.resolve(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+    });
+    globalThis.fetch = fetchMock as any;
+
+    const client = createThrottledFetch({ maxRetries: 1, backoffBaseMs: 0 });
+    const resp = await client.fetch("https://api.example.com/test");
+    expect(resp.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  test("retries on 500 with backoff", async () => {
+    let callCount = 0;
+    fetchMock = mock(() => {
+      callCount++;
+      if (callCount === 1) {
+        return Promise.resolve(new Response("error", { status: 500 }));
+      }
+      return Promise.resolve(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+    });
+    globalThis.fetch = fetchMock as any;
+
+    const client = createThrottledFetch({ maxRetries: 1, backoffBaseMs: 0 });
+    const resp = await client.fetch("https://api.example.com/test");
+    expect(resp.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  test("retries transient fetch failures", async () => {
+    let callCount = 0;
+    fetchMock = mock(() => {
+      callCount++;
+      if (callCount === 1) {
+        return Promise.reject(
+          Object.assign(new Error("The socket connection was closed unexpectedly."), {
+            code: "ECONNRESET",
+          }),
+        );
+      }
+      return Promise.resolve(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+    });
+    globalThis.fetch = fetchMock as any;
+
+    const client = createThrottledFetch({ maxRetries: 1, backoffBaseMs: 0 });
+    const resp = await client.fetch("https://api.example.com/test");
+    expect(resp.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  test("stops retrying after max retries", async () => {
+    fetchMock = mock(() => Promise.resolve(new Response("error", { status: 429 })));
+    globalThis.fetch = fetchMock as any;
+
+    const client = createThrottledFetch({ maxRetries: 1, backoffBaseMs: 0 });
+    const resp = await client.fetch("https://api.example.com/test");
+    expect(resp.status).toBe(429);
+    expect(fetchMock).toHaveBeenCalledTimes(2); // initial + 1 retry
+  });
+
+  test("fetchJson parses response and throws on error", async () => {
+    const client = createThrottledFetch();
+    const data = await client.fetchJson<{ ok: boolean }>("https://api.example.com/test");
+    expect(data).toEqual({ ok: true });
+
+    fetchMock = mock(() => Promise.resolve(new Response("not found", { status: 404 })));
+    globalThis.fetch = fetchMock as any;
+    const client2 = createThrottledFetch({ maxRetries: 0 });
+    await expect(client2.fetchJson("https://api.example.com/test")).rejects.toThrow("HTTP 404");
+  });
+
+  test("fetchJson throws friendly message on 429", async () => {
+    fetchMock = mock(() => Promise.resolve(new Response("", { status: 429 })));
+    globalThis.fetch = fetchMock as any;
+
+    const client = createThrottledFetch({ maxRetries: 0 });
+    await expect(client.fetchJson("https://api.example.com/test")).rejects.toThrow("Rate limited");
+  });
+});
+
+// Restore
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+});

package/src/utils/throttled-fetch.ts

@@ -0,0 +1,212 @@
+/**
+ * Rate-limited fetch with per-host throttling, retry with backoff, and request deduplication.
+ *
+ * Usage:
+ *   const client = createThrottledFetch({ requestsPerMinute: 30 });
+ *   const data = await client.fetch("https://api.example.com/data");
+ */
+
+const DEFAULT_REQUESTS_PER_MINUTE = 30;
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_TIMEOUT_MS = 10_000;
+const BACKOFF_BASE_MS = 1_000;
+
+export interface ThrottledFetchOptions {
+  /** Max requests per minute per host. Default: 30 */
+  requestsPerMinute?: number;
+  /** Max retries on 429 or 5xx. Default: 2 */
+  maxRetries?: number;
+  /** Request timeout in ms. Default: 10000 */
+  timeoutMs?: number;
+  /** Initial retry backoff in ms. Default: 1000 */
+  backoffBaseMs?: number;
+  /** Default headers applied to every request */
+  defaultHeaders?: Record<string, string>;
+  /** Share concurrent GET requests to the same URL. Default: true */
+  dedupeGetRequests?: boolean;
+}
+
+interface QueueEntry {
+  resolve: (value: Response) => void;
+  reject: (reason: unknown) => void;
+  url: string;
+  init: RequestInit | undefined;
+  retries: number;
+}
+
+export interface ThrottledFetchClient {
+  fetch(url: string, init?: RequestInit): Promise<Response>;
+  fetchJson<T = unknown>(url: string, init?: RequestInit): Promise<T>;
+}
+
+export function createThrottledFetch(
+  options: ThrottledFetchOptions = {},
+): ThrottledFetchClient {
+  const requestsPerMinute =
+    options.requestsPerMinute ?? DEFAULT_REQUESTS_PER_MINUTE;
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const backoffBaseMs = options.backoffBaseMs ?? BACKOFF_BASE_MS;
+  const defaultHeaders = options.defaultHeaders ?? {};
+  const dedupeGetRequests = options.dedupeGetRequests ?? true;
+
+  // Sliding window: track timestamps of recent requests per host
+  const hostTimestamps = new Map<string, number[]>();
+
+  // Deduplication: in-flight requests by URL
+  const inflight = new Map<string, Promise<Response>>();
+
+  function getHost(url: string): string {
+    try {
+      return new URL(url).host;
+    } catch {
+      return "unknown";
+    }
+  }
+
+  function getDelayMs(host: string): number {
+    const timestamps = hostTimestamps.get(host);
+    if (!timestamps || timestamps.length === 0) return 0;
+
+    const windowStart = Date.now() - 60_000;
+    // Prune old entries
+    while (timestamps.length > 0 && timestamps[0]! < windowStart) {
+      timestamps.shift();
+    }
+
+    if (timestamps.length < requestsPerMinute) return 0;
+
+    // Delay until the oldest request in the window falls outside
+    const oldest = timestamps[0]!;
+    return Math.max(0, oldest + 60_000 - Date.now() + 50); // +50ms buffer
+  }
+
+  function recordRequest(host: string): void {
+    let timestamps = hostTimestamps.get(host);
+    if (!timestamps) {
+      timestamps = [];
+      hostTimestamps.set(host, timestamps);
+    }
+    timestamps.push(Date.now());
+  }
+
+  function getBackoffMs(retriesLeft: number, retryAfter?: string | null): number {
+    const attempt = maxRetries - retriesLeft + 1;
+    const backoff = backoffBaseMs * 2 ** (attempt - 1);
+    const retryAfterMs = retryAfter
+      ? (parseInt(retryAfter, 10) || 0) * 1000
+      : 0;
+    return Math.max(retryAfterMs, backoff);
+  }
+
+  function isRetryableFetchError(
+    error: unknown,
+    retryAbortError: boolean,
+  ): boolean {
+    const detail =
+      error instanceof Error
+        ? `${error.name} ${error.message} ${String((error as { code?: unknown }).code ?? "")}`
+        : String(error);
+    return (
+      /TimeoutError|ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket connection|socket hang up|fetch failed|network connection|connection closed/i.test(
+        detail,
+      ) ||
+      (retryAbortError && /AbortError/i.test(detail))
+    );
+  }
+
+  async function executeRequest(
+    url: string,
+    init: RequestInit | undefined,
+    retriesLeft: number,
+  ): Promise<Response> {
+    const host = getHost(url);
+
+    // Wait for rate limit window
+    const delay = getDelayMs(host);
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+
+    recordRequest(host);
+
+    const mergedInit: RequestInit = {
+      ...init,
+      headers: {
+        ...defaultHeaders,
+        ...((init?.headers as Record<string, string>) ?? {}),
+      },
+      signal: init?.signal ?? AbortSignal.timeout(timeoutMs),
+    };
+
+    let resp: Response;
+    try {
+      resp = await fetch(url, mergedInit);
+    } catch (error) {
+      if (retriesLeft > 0 && isRetryableFetchError(error, !init?.signal)) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, getBackoffMs(retriesLeft)),
+        );
+        return executeRequest(url, init, retriesLeft - 1);
+      }
+      throw error;
+    }
+
+    // Retry on 429 or 5xx
+    if ((resp.status === 429 || resp.status >= 500) && retriesLeft > 0) {
+      await new Promise((resolve) =>
+        setTimeout(
+          resolve,
+          getBackoffMs(retriesLeft, resp.headers.get("retry-after")),
+        ),
+      );
+      return executeRequest(url, init, retriesLeft - 1);
+    }
+
+    return resp;
+  }
+
+  function throttledFetch(url: string, init?: RequestInit): Promise<Response> {
+    // Deduplicate concurrent GET requests to the same URL
+    const method = (init?.method ?? "GET").toUpperCase();
+    if (dedupeGetRequests && method === "GET") {
+      const existing = inflight.get(url);
+      if (existing) {
+        return existing.then(
+          (response): Response => response.clone() as unknown as Response,
+        );
+      }
+    }
+
+    const promise = executeRequest(url, init, maxRetries).finally(() => {
+      inflight.delete(url);
+    });
+
+    if (dedupeGetRequests && method === "GET") {
+      inflight.set(url, promise);
+    }
+
+    return dedupeGetRequests && method === "GET"
+      ? promise.then(
+          (response): Response => response.clone() as unknown as Response,
+        )
+      : promise;
+  }
+
+  async function fetchJson<T = unknown>(
+    url: string,
+    init?: RequestInit,
+  ): Promise<T> {
+    const resp = await throttledFetch(url, init);
+    if (!resp.ok) {
+      throw new Error(
+        resp.status === 429
+          ? `Rate limited (${getHost(url)}) — try again later`
+          : `HTTP ${resp.status} from ${getHost(url)}`,
+      );
+    }
+    return resp.json() as Promise<T>;
+  }
+
+  return { fetch: throttledFetch, fetchJson };
+}

package/src/utils/ticker-tokenizer.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { collectUniqueTickerSymbols, tokenizeTickerText } from "./ticker-tokenizer";
+
+describe("tokenizeTickerText", () => {
+  test("finds normal inline ticker symbols", () => {
+    expect(tokenizeTickerText("Watching $TSLA and $NVDA")).toEqual([
+      { kind: "text", value: "Watching " },
+      { kind: "ticker", value: "$TSLA", symbol: "TSLA" },
+      { kind: "text", value: " and " },
+      { kind: "ticker", value: "$NVDA", symbol: "NVDA" },
+    ]);
+  });
+
+  test("does not tokenize ticker-like text inside links", () => {
+    expect(tokenizeTickerText("Read https://example.com/$TSLA before buying $NVDA")).toEqual([
+      { kind: "text", value: "Read " },
+      { kind: "text", value: "https://example.com/$TSLA" },
+      { kind: "text", value: " before buying " },
+      { kind: "ticker", value: "$NVDA", symbol: "NVDA" },
+    ]);
+  });
+});
+
+describe("collectUniqueTickerSymbols", () => {
+  test("ignores ticker-like text inside links", () => {
+    expect(collectUniqueTickerSymbols([
+      "Read https://example.com/$TSLA",
+      "Watching $NVDA",
+    ])).toEqual(["NVDA"]);
+  });
+});

package/src/utils/ticker-tokenizer.ts

@@ -1,3 +1,5 @@
+import { tokenizeInlineContent } from "./inline-content-tokenizer";
+
 export interface InlineTickerTextToken {
   kind: "text";
   value: string;
@@ -11,49 +13,12 @@ export interface InlineTickerSymbolToken {
 
 export type InlineTickerToken = InlineTickerTextToken | InlineTickerSymbolToken;
 
-const TICKER_TOKEN_RE = /\$[A-Z][A-Z0-9.-]{0,9}/g;
-const SYMBOL_CHAR_RE = /[A-Za-z0-9.-]/;
-
-function trimTrailingPunctuation(value: string): string {
-  let trimmed = value;
-  while (trimmed.length > 2 && /[.-]$/.test(trimmed)) {
-    trimmed = trimmed.slice(0, -1);
-  }
-  return trimmed;
-}
-
-function isValidBoundary(text: string, start: number, end: number): boolean {
-  const prev = start > 0 ? text[start - 1] : "";
-  const next = end < text.length ? text[end] : "";
-  return !SYMBOL_CHAR_RE.test(prev) && !SYMBOL_CHAR_RE.test(next);
-}
-
 export function tokenizeTickerText(text: string): InlineTickerToken[] {
-  const tokens: InlineTickerToken[] = [];
-  let cursor = 0;
-  let match: RegExpExecArray | null;
-
-  TICKER_TOKEN_RE.lastIndex = 0;
-  while ((match = TICKER_TOKEN_RE.exec(text)) !== null) {
-    const rawValue = match[0];
-    const start = match.index;
-    const rawEnd = start + rawValue.length;
-    const value = trimTrailingPunctuation(rawValue);
-    const end = start + value.length;
-    if (!isValidBoundary(text, start, rawEnd)) continue;
-
-    if (start > cursor) {
-      tokens.push({ kind: "text", value: text.slice(cursor, start) });
-    }
-    tokens.push({ kind: "ticker", value, symbol: value.slice(1) });
-    cursor = end;
-  }
-
-  if (cursor < text.length) {
-    tokens.push({ kind: "text", value: text.slice(cursor) });
-  }
-
-  return tokens;
+  return tokenizeInlineContent(text).map((token) => (
+    token.kind === "ticker"
+      ? token
+      : { kind: "text", value: token.value }
+  ));
 }
 
 export function collectUniqueTickerSymbols(texts: readonly string[]): string[] {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.4.1";
+export const VERSION = "0.5.0";