fix(api): retry internal GitHub request timeouts (JhaSourav07#1947)

## Description

Closes JhaSourav07#1942

## Pillar

- [x] 🛠️ Other (Bug fix, refactoring, docs)

## What changed

`fetchWithRetry` already retries network failures, 5xx responses, and
GitHub rate-limit responses, but request timeouts caused by the helper's
own `AbortController` were thrown immediately on the first attempt.

This PR routes internal timeout aborts through the existing
retry/backoff path. Caller-provided abort signals still exit
immediately, so user cancellation behavior is unchanged.

I also added regression coverage for:

- an internal timeout followed by a successful retry
- internal timeouts exhausting all retry attempts
- the existing caller-abort behavior staying non-retryable

This is a GSSoC 2026 API reliability bug fix contribution. Please add
the relevant GSSoC labels if they are missing.

## Visual Preview

N/A — this is API retry behavior and test coverage only.

## Local checks

```bash
npm run test -- lib/github.test.ts
npm run format:check
npm run lint
npm run typecheck
npm run test
```

`npm run lint` reports 4 existing warnings outside the touched files;
there are no lint errors.

## Checklist before requesting a review:

- [x] I have read the `CONTRIBUTING.md` file.
- [x] I have tested these changes locally.
- [x] I have run `npm run format` and `npm run lint` locally and
resolved all errors.
- [x] My commit follows the Conventional Commits format.
- [x] I have updated `README.md` if I added a new theme or URL
parameter.
- [x] I have starred the repo.
- [x] I have made sure that I have only one commit to merge in this PR.
- [x] The SVG output matches the CommitPulse quality standard.

Author: JhaSourav07

lib/github.test.ts

@@ -118,6 +118,57 @@ describe('fetchWithRetry', () => {
     expect(fetch).toHaveBeenCalledOnce();
   });
 
+  it('retries when the internal request timeout aborts fetch', async () => {
+    vi.mocked(fetch)
+      .mockImplementationOnce(
+        (_url: RequestInfo | URL, options?: RequestInit) =>
+          new Promise<Response>((_resolve, reject) => {
+            options?.signal?.addEventListener(
+              'abort',
+              () => reject(new DOMException('Timed out', 'AbortError')),
+              { once: true }
+            );
+          })
+      )
+      .mockResolvedValueOnce(new Response('ok', { status: 200 }));
+
+    const promise = fetchWithRetry('https://api.github.com/test', {}, 0, 100);
+
+    await vi.advanceTimersByTimeAsync(100);
+    await vi.advanceTimersByTimeAsync(500);
+
+    const res = await promise;
+    expect(res.status).toBe(200);
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('throws a timeout error after internal timeout retries are exhausted', async () => {
+    vi.mocked(fetch).mockImplementation(
+      (_url: RequestInfo | URL, options?: RequestInit) =>
+        new Promise<Response>((_resolve, reject) => {
+          options?.signal?.addEventListener(
+            'abort',
+            () => reject(new DOMException('Timed out', 'AbortError')),
+            { once: true }
+          );
+        })
+    );
+
+    const promise = fetchWithRetry('https://api.github.com/test', {}, 0, 100);
+    const expectation = expect(promise).rejects.toThrow('GitHub API request timed out after 0.1s');
+
+    await vi.advanceTimersByTimeAsync(100);
+    await vi.advanceTimersByTimeAsync(500);
+    await vi.advanceTimersByTimeAsync(100);
+    await vi.advanceTimersByTimeAsync(1000);
+    await vi.advanceTimersByTimeAsync(100);
+    await vi.advanceTimersByTimeAsync(2000);
+    await vi.advanceTimersByTimeAsync(100);
+
+    await expectation;
+    expect(fetch).toHaveBeenCalledTimes(4);
+  });
+
   it('retries on 429 with numeric retry-after', async () => {
     vi.mocked(fetch)
       .mockResolvedValueOnce(new Response(null, { status: 429, headers: { 'retry-after': '2' } }))

lib/github.ts

@@ -28,6 +28,15 @@ const MAX_RETRY_DELAY_MS = 5000;
 const GRAPHQL_TIMEOUT_MS = 8000; // 8s for GraphQL endpoint
 const REST_TIMEOUT_MS = 5000; // 5s for REST endpoints
 
+function isAbortError(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'name' in error &&
+    (error as { name?: unknown }).name === 'AbortError'
+  );
+}
+
 export async function fetchWithRetry(
   url: string | URL,
   options: RequestInit,
@@ -63,10 +72,13 @@ export async function fetchWithRetry(
 
   if (didThrow) {
     if (options.signal?.aborted) throw fetchError;
-    if (fetchError instanceof Error && fetchError.name === 'AbortError') {
-      throw new Error(`GitHub API request timed out after ${resolvedTimeout / 1000}s`);
+    const isTimeoutAbort = isAbortError(fetchError);
+    if (attempt >= MAX_RETRIES) {
+      if (isTimeoutAbort) {
+        throw new Error(`GitHub API request timed out after ${resolvedTimeout / 1000}s`);
+      }
+      throw fetchError;
     }
-    if (attempt >= MAX_RETRIES) throw fetchError;
     const delay = BASE_DELAY_MS * Math.pow(2, attempt);
     await new Promise((resolve) => setTimeout(resolve, delay));
     return fetchWithRetry(url, options, attempt + 1, timeoutMs);