@shiinasaku/github-card 2.0.0 → 4.1.0

package/src/github.ts

@@ -1,572 +1,440 @@
-import type { ProfileData, LanguageStat } from "./types";
-
-export class NotFoundError extends Error {
-  constructor(message = "User not found") {
-    super(message);
-    this.name = "NotFoundError";
-  }
-}
-
-export class RateLimitError extends Error {
-  constructor(message = "GitHub API rate limit exceeded") {
-    super(message);
-    this.name = "RateLimitError";
-  }
-}
-
-export class AuthError extends Error {
-  constructor(message = "GitHub authentication failed") {
-    super(message);
-    this.name = "AuthError";
-  }
-}
-
-export class UpstreamError extends Error {
-  constructor(message = "GitHub API request failed") {
-    super(message);
-    this.name = "UpstreamError";
+import type { ProfileData } from "./types";
+import { RedisClient } from "bun";
+import {
+  GitHubClient,
+  NotFoundError,
+  RateLimitError,
+  AuthError,
+  GitHubError as UpstreamError,
+} from "./utils/github-client";
+
+export { NotFoundError, RateLimitError, AuthError, UpstreamError };
+
+const githubClient = new GitHubClient({
+  token: Bun.env.GITHUB_TOKEN || process.env?.GITHUB_TOKEN || "",
+  userAgent: "github-card",
+});
+
+const CACHE_FRESH_MS = 30 * 60 * 1000;
+const CACHE_STALE_MS = 30 * 60 * 1000;
+const CACHE_VERSION = 7;
+const REDIS_TTL_SECONDS = Math.ceil((CACHE_FRESH_MS + CACHE_STALE_MS) / 1000);
+const FETCH_TIMEOUT_MS = 6000;
+const AVATAR_TIMEOUT_MS = 4000;
+const MAX_AVATAR_BYTES = 256 * 1024;
+const MAX_PAGES = 5;
+const REPO_PAGE_SIZE = 100;
+const MAX_L1_ENTRIES = 1000;
+const REDIS_PROFILE_PREFIX = "profile:";
+
+let redisClient: RedisClient | null = null;
+try {
+  if (Bun.env.REDIS_URL) {
+    redisClient = new RedisClient(Bun.env.REDIS_URL);
   }
+} catch (e) {
+  console.error("Bun RedisClient failed to initialize", e);
 }
 
-function classifyGraphQLError(message: string): Error | null {
-  const lower = message.toLowerCase();
-
-  if (
-    lower.includes("could not resolve to a user") ||
-    lower.includes("not found") ||
-    lower.includes("couldn't find user")
-  ) {
-    return new NotFoundError("User not found");
-  }
-
-  if (lower.includes("rate limit") || lower.includes("api rate limit exceeded")) {
-    return new RateLimitError("GitHub API rate limit exceeded");
-  }
-
-  if (
-    lower.includes("bad credentials") ||
-    lower.includes("requires authentication") ||
-    lower.includes("resource not accessible")
-  ) {
-    return new AuthError("GitHub authentication failed");
+export async function isRedisReachable(): Promise<boolean> {
+  if (!redisClient) return false;
+  try {
+    return (await redisClient.ping()) === "PONG";
+  } catch {
+    return false;
   }
-
-  return null;
 }
 
-function classifyHttpError(status: number, bodyText: string): Error {
-  const lower = bodyText.toLowerCase();
-
-  if (status === 401 || lower.includes("bad credentials")) {
-    return new AuthError("GitHub authentication failed");
-  }
-
-  if (status === 403 && (lower.includes("rate limit") || lower.includes("abuse detection"))) {
-    return new RateLimitError("GitHub API rate limit exceeded");
-  }
+type CachedData = {
+  v: number;
+  staleAt: number;
+  expiresAt: number;
+  data: ProfileData;
+};
 
-  if (status === 404) {
-    return new NotFoundError("User not found");
-  }
+const memCache = new Map<string, CachedData>();
+const inFlight = new Map<string, Promise<ProfileData>>();
+const refreshInFlight = new Set<string>();
 
-  return new UpstreamError(`GitHub API error (${status})`);
+function evictL1IfNeeded() {
+  if (memCache.size <= MAX_L1_ENTRIES) return;
+  const oldestKey = memCache.keys().next().value as string | undefined;
+  if (oldestKey) memCache.delete(oldestKey);
 }
 
-function getHeaders() {
-  const token = Bun.env.GITHUB_TOKEN;
-  if (!token) throw new AuthError("GITHUB_TOKEN is missing");
-  return {
-    Authorization: `bearer ${token}`,
-    "Content-Type": "application/json",
-    "User-Agent": "github-card",
-  };
+function setMemoryCache(cacheKey: string, payload: CachedData) {
+  memCache.set(cacheKey, payload);
+  evictL1IfNeeded();
 }
 
-const LANG_FIELDS = `languages(first: 10, orderBy: {field: SIZE, direction: DESC}) {
-          edges { size node { color name } }
-        }`;
-
-const USER_META_FIELDS = `
-    login name avatarUrl bio pronouns twitterUsername
-    openPRs: pullRequests(states: OPEN) { totalCount }
-    closedPRs: pullRequests(states: CLOSED) { totalCount }
-    mergedPRs: pullRequests(states: MERGED) { totalCount }
-    openIssues: issues(states: OPEN) { totalCount }
-    closedIssues: issues(states: CLOSED) { totalCount }
-    contributionsCollection(from: $from, to: $to) { totalCommitContributions }`;
-
-function buildUserReposQuery(langs: boolean): string {
-  return `query userInfo($login: String!, $cursor: String, $from: DateTime!, $to: DateTime!) {
-  user(login: $login) {
-    ${USER_META_FIELDS}
-    repositories(first: 100, ownerAffiliations: OWNER, isFork: false, orderBy: {direction: DESC, field: STARGAZERS}, after: $cursor) {
-      totalCount
-      pageInfo { hasNextPage endCursor }
-      nodes {
-        stargazers { totalCount }
-        ${langs ? LANG_FIELDS : ""}
-      }
-    }
-  }
-}`;
+async function writeRedisCache(cacheKey: string, payload: CachedData) {
+  if (!redisClient) return;
+  try {
+    await redisClient.set(
+      `${REDIS_PROFILE_PREFIX}${cacheKey}`,
+      JSON.stringify(payload),
+      "EX",
+      REDIS_TTL_SECONDS,
+    );
+  } catch {}
 }
 
-function buildOrgContribsQuery(langs: boolean): string {
-  return `query orgContribs($login: String!, $cursor: String) {
-  user(login: $login) {
-    repositoriesContributedTo(
-      first: 100
-      contributionTypes: [COMMIT, PULL_REQUEST, REPOSITORY]
-      includeUserRepositories: false
-      after: $cursor
-    ) {
-      totalCount
-      pageInfo { hasNextPage endCursor }
-      nodes {
-        owner { login __typename }
-        stargazers { totalCount }
-        ${langs ? LANG_FIELDS : ""}
-      }
-    }
-  }
-}`;
-}
+async function readRedisCache(cacheKey: string, now: number): Promise<CachedData | null> {
+  if (!redisClient) return null;
+  try {
+    const raw = await redisClient.get(`${REDIS_PROFILE_PREFIX}${cacheKey}`);
+    if (!raw) return null;
 
-const QUERY_USER_META = `
-query userMeta($login: String!, $from: DateTime!, $to: DateTime!) {
-  user(login: $login) {
-    ${USER_META_FIELDS}
+    const parsed = JSON.parse(raw) as CachedData;
+    if (parsed.v !== CACHE_VERSION || parsed.expiresAt <= now || !parsed.data) return null;
+    return parsed;
+  } catch {
+    return null;
   }
-}`;
-
-const CACHE_FRESH_SECONDS = 30 * 60;
-const CACHE_STALE_SECONDS = 30 * 60;
-const FETCH_TIMEOUT_MS = 8000;
-const MAX_PAGES = 10; // Safety: 10 pages × 100 items = 1000 max
-type CacheEntry = {
-  staleAt: number;
-  expiresAt: number;
-  value?: ProfileData;
-  inFlight?: Promise<ProfileData>;
-};
-const cache = new Map<string, CacheEntry>();
-
-type FetchOptions = {
-  includeLanguages?: boolean;
-  langCount?: number;
-  scope?: "personal" | "org" | "all";
-  orgs?: string[];
-  forceRefresh?: boolean;
-};
-
-function normalizeScope(value?: string): "personal" | "org" | "all" {
-  if (value === "org" || value === "all") return value;
-  return "personal";
 }
 
-const redisUrl = Bun.env.UPSTASH_REDIS_REST_URL || Bun.env.KV_REST_API_URL || "";
-const redisToken = Bun.env.UPSTASH_REDIS_REST_TOKEN || Bun.env.KV_REST_API_TOKEN || "";
-let redisPromise: Promise<import("@upstash/redis").Redis | null> | null = null;
-
-function buildCacheKey(raw: string): string {
-  return Bun.hash(raw).toString(36);
-}
+async function saveProfileCache(cacheKey: string, data: ProfileData): Promise<ProfileData> {
+  const now = Date.now();
+  const payload: CachedData = {
+    v: CACHE_VERSION,
+    staleAt: now + CACHE_FRESH_MS,
+    expiresAt: now + CACHE_FRESH_MS + CACHE_STALE_MS,
+    data,
+  };
 
-async function getRedis() {
-  if (!redisUrl || !redisToken) return null;
-  if (!redisPromise) {
-    redisPromise = import("@upstash/redis")
-      .then((mod) => new mod.Redis({ url: redisUrl, token: redisToken }))
-      .catch(() => null);
-  }
-  return redisPromise;
+  setMemoryCache(cacheKey, payload);
+  await writeRedisCache(cacheKey, payload);
+  return data;
 }
 
 export function getCacheMetrics() {
-  const now = Date.now();
   let fresh = 0;
   let stale = 0;
   let expired = 0;
-
-  for (const entry of cache.values()) {
-    if (entry.expiresAt <= now) {
-      expired++;
-      continue;
-    }
-    if (entry.staleAt <= now) stale++;
+  const now = Date.now();
+  for (const entry of memCache.values()) {
+    if (entry.expiresAt <= now) expired++;
+    else if (entry.staleAt <= now) stale++;
     else fresh++;
   }
-
   return {
-    total: cache.size,
+    total: memCache.size,
+    maxEntries: MAX_L1_ENTRIES,
     fresh,
     stale,
     expired,
-    ttlFreshSeconds: CACHE_FRESH_SECONDS,
-    ttlStaleSeconds: CACHE_STALE_SECONDS,
+    ttlFreshSeconds: 1800,
+    ttlStaleSeconds: 1800,
   };
 }
 
-export async function isRedisReachable(): Promise<boolean> {
-  const redis = await getRedis();
-  if (!redis) return false;
-  try {
-    await redis.ping();
-    return true;
-  } catch {
-    return false;
-  }
+function normalizeUsername(username: string): string {
+  return username.trim().toLowerCase();
 }
 
-function getCacheState(cacheKey: string): { value: ProfileData; stale: boolean } | null {
-  const entry = cache.get(cacheKey);
-  if (!entry || !entry.value) return null;
-  if (entry.expiresAt <= Date.now()) {
-    cache.delete(cacheKey);
-    return null;
-  }
-  return { value: entry.value, stale: entry.staleAt <= Date.now() };
+function normalizeOrgFilters(orgs?: string[]): string[] {
+  return Array.from(new Set((orgs || []).map((o) => o.trim().toLowerCase()).filter(Boolean)));
 }
 
-function setCache(cacheKey: string, value: ProfileData) {
-  const now = Date.now();
-  cache.set(cacheKey, {
-    staleAt: now + CACHE_FRESH_SECONDS * 1000,
-    expiresAt: now + (CACHE_FRESH_SECONDS + CACHE_STALE_SECONDS) * 1000,
-    value,
-  });
-}
+type FetchOptions = {
+  includeLanguages?: boolean;
+  langCount?: number;
+  scope?: "personal" | "org" | "all";
+  orgs?: string[];
+  affiliations?: "owner" | "affiliated";
+  forceRefresh?: boolean;
+};
 
-function accumulateLanguageEdges(
-  edges: Array<{ size: number; node: { color?: string; name?: string } }> = [],
-  map: Map<string, { size: number; color: string }>,
-) {
-  for (const edge of edges) {
-    if (!edge?.node?.name || !edge.size) continue;
-    const current = map.get(edge.node.name);
-    if (current) {
-      current.size += edge.size;
-    } else {
-      map.set(edge.node.name, { size: edge.size, color: edge.node.color || "#ccc" });
+const QUERY_PROFILE = `
+query fullProfile($login: String!, $from: DateTime!, $to: DateTime!, $isOrg: Boolean!) {
+  user(login: $login) {
+    login name avatarUrl bio pronouns twitterUsername
+    openPRs: pullRequests(states: OPEN) { totalCount }
+    closedPRs: pullRequests(states: CLOSED) { totalCount }
+    mergedPRs: pullRequests(states: MERGED) { totalCount }
+    openIssues: issues(states: OPEN) { totalCount }
+    closedIssues: issues(states: CLOSED) { totalCount }
+    contributionsCollection(from: $from, to: $to) {
+      totalCommitContributions
+      commitContributionsByRepository(maxRepositories: 100) @include(if: $isOrg) { repository { owner { login __typename } } contributions(first:1) { totalCount } }
+      pullRequestContributionsByRepository(maxRepositories: 100) @include(if: $isOrg) { repository { owner { login __typename } } contributions(first:1) { totalCount } }
+      issueContributionsByRepository(maxRepositories: 100) @include(if: $isOrg) { repository { owner { login __typename } } contributions(first:1) { totalCount } }
     }
   }
 }
+`;
 
-type LangMap = Map<string, { size: number; color: string }>;
-
-/** Merges multiple language maps into one, summing sizes for duplicates. */
-function mergeLangMaps(...maps: (LangMap | null)[]): LangMap {
-  const merged: LangMap = new Map();
-  for (const map of maps) {
-    if (!map) continue;
-    for (const [name, val] of map) {
-      const cur = merged.get(name);
-      if (cur) cur.size += val.size;
-      else merged.set(name, { size: val.size, color: val.color });
-    }
+const QUERY_ORG = `
+query fullOrg($login: String!) {
+  organization(login: $login) {
+    login name avatarUrl description twitterUsername
   }
-  return merged;
 }
+`;
 
-/** Sorts a language map by size descending to produce final LanguageStat[]. */
-function buildLanguageStats(map: LangMap, limit: number): LanguageStat[] {
-  return Array.from(map)
-    .sort((a, b) => b[1].size - a[1].size)
-    .slice(0, limit)
-    .map(([name, { size, color }]) => ({ name, size, color }));
+const QUERY_PAGINATE_USER_REPOS = `
+query paginateRepos($login: String!, $cursor: String, $pageSize: Int!, $affiliations: [RepositoryAffiliation!], $fetchLangs: Boolean!) {
+  user(login: $login) {
+    repositories(first: $pageSize, after: $cursor, ownerAffiliations: $affiliations, isFork: false, orderBy: {direction: DESC, field: STARGAZERS}) {
+      pageInfo { hasNextPage endCursor }
+      nodes { nameWithOwner stargazers { totalCount } languages(first: 10, orderBy: {field: SIZE, direction: DESC}) @include(if: $fetchLangs) { edges { size node { color name } } } }
+    }
+  }
 }
+`;
 
-async function postGraphQL(query: string, variables: Record<string, unknown>): Promise<any> {
-  let res: Response;
-  try {
-    res = await fetch("https://api.github.com/graphql", {
-      method: "POST",
-      headers: getHeaders(),
-      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-      body: JSON.stringify({ query, variables }),
-    });
-  } catch (error: any) {
-    if (error?.name === "TimeoutError" || error?.name === "AbortError") {
-      throw new UpstreamError("GitHub API request timed out");
+const QUERY_PAGINATE_ORG_CONTRIBS = `
+query paginateOrgContribs($login: String!, $cursor: String, $pageSize: Int!, $fetchLangs: Boolean!) {
+  user(login: $login) {
+    repositoriesContributedTo(first: $pageSize, contributionTypes: [COMMIT, PULL_REQUEST, REPOSITORY], includeUserRepositories: false, after: $cursor) {
+      pageInfo { hasNextPage endCursor }
+      nodes { nameWithOwner owner { login __typename } stargazers { totalCount } languages(first: 10, orderBy: {field: SIZE, direction: DESC}) @include(if: $fetchLangs) { edges { size node { color name } } } }
     }
-    throw new UpstreamError("GitHub API request failed");
   }
+}
+`;
 
-  if (!res.ok) {
-    const text = await res.text();
-    throw classifyHttpError(res.status, text);
+const QUERY_PAGINATE_ORG_REPOS = `
+query paginateOrg($login: String!, $cursor: String, $pageSize: Int!, $fetchLangs: Boolean!) {
+  organization(login: $login) {
+    repositories(first: $pageSize, isFork: false, orderBy: {direction: DESC, field: STARGAZERS}, after: $cursor) {
+      pageInfo { hasNextPage endCursor }
+      nodes { nameWithOwner stargazers { totalCount } languages(first: 10, orderBy: {field: SIZE, direction: DESC}) @include(if: $fetchLangs) { edges { size node { color name } } } }
+    }
   }
+}
+`;
 
-  const body = (await res.json()) as { data?: Record<string, any>; errors?: Array<{ message: string }> };
-  if (body.errors?.length) {
-    const msg =
-      body.errors
-        .map((e) => e.message)
-        .filter(Boolean)
-        .join(" | ") || "GitHub API error";
-    throw classifyGraphQLError(msg) || new UpstreamError(msg);
-  }
+async function postGraphQL(query: string, variables: Record<string, unknown>) {
+  return githubClient.request(query, {
+    variables,
+    timeoutMs: FETCH_TIMEOUT_MS,
+  });
+}
 
-  if (!body.data) {
-    throw new UpstreamError("GitHub API returned no data");
+type LangMap = Map<string, { size: number; color: string }>;
+function accLangs(edges: any[], map: LangMap) {
+  if (!edges) return;
+  for (const e of edges) {
+    if (!e?.node?.name || !e.size) continue;
+    const cur = map.get(e.node.name);
+    if (cur) cur.size += e.size;
+    else map.set(e.node.name, { size: e.size, color: e.node.color || "#ccc" });
   }
-
-  return body;
 }
 
-type RepoResult = { stars: number; repos: number; langMap: LangMap | null };
-type PersonalResult = RepoResult & { user: any };
-
-/** Fetches an avatar image and returns it as a base64 data URI. */
-async function fetchAvatarDataUrl(url: string): Promise<string> {
+async function fetchAvatarAsBase64(url: string | null | undefined): Promise<string> {
+  if (!url) return "";
   try {
-    const res = await fetch(url, {
-      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-      headers: { "User-Agent": "github-card" },
+    const target = new URL(url);
+    target.searchParams.set("s", "150");
+    const res = await fetch(target.toString(), {
+      signal: AbortSignal.timeout(AVATAR_TIMEOUT_MS),
     });
     if (!res.ok) return url;
+    const contentType = res.headers.get("content-type") || "image/png";
+    if (!contentType.toLowerCase().startsWith("image/")) return url;
+    const contentLength = Number(res.headers.get("content-length") || 0);
+    if (contentLength > MAX_AVATAR_BYTES) return url;
     const buf = await res.arrayBuffer();
-    const mime = res.headers.get("content-type") || "image/png";
-    return `data:${mime};base64,${Buffer.from(buf).toString("base64")}`;
+    if (buf.byteLength > MAX_AVATAR_BYTES) return url;
+    return `data:${contentType};base64,${Buffer.from(buf).toString("base64")}`;
   } catch {
-    return url; // fallback to raw URL
+    return url;
   }
 }
 
-/** Fetches user metadata only (no repos). */
-async function fetchUserMeta(username: string, from: string, to: string): Promise<any> {
-  const body = await postGraphQL(QUERY_USER_META, { login: username, from, to });
-  if (!body.data?.user) throw new NotFoundError("User not found");
-  return body.data.user;
+function sumContributions(entries: any[], orgsSet: Set<string> | null) {
+  let tot = 0;
+  for (const e of entries || []) {
+    const owner = e?.repository?.owner;
+    if (owner?.__typename !== "Organization" || !owner?.login) continue;
+    if (orgsSet && !orgsSet.has(owner.login.toLowerCase())) continue;
+    tot += e?.contributions?.totalCount || 0;
+  }
+  return tot;
 }
 
-/** Paginates user-owned repos and returns stars, repo count, language map, and user metadata. */
-async function fetchPersonalRepos(
-  username: string,
-  langs: boolean,
-  from: string,
-  to: string,
-): Promise<PersonalResult> {
-  const query = buildUserReposQuery(langs);
-  const langMap: LangMap | null = langs ? new Map() : null;
-  let hasNext = true;
-  let cursor: string | null = null;
+async function directFetch(username: string, opts: FetchOptions): Promise<ProfileData> {
+  const isPersonal = opts.scope !== "org";
+  const isOrg = opts.scope === "org" || opts.scope === "all";
+  const fetchLangs = opts.includeLanguages ?? true;
+  const orgsArr = normalizeOrgFilters(opts.orgs);
+  const orgsSet = orgsArr.length > 0 ? new Set(orgsArr) : null;
+  const affiliations =
+    opts.affiliations === "owner" ? ["OWNER"] : ["OWNER", "ORGANIZATION_MEMBER", "COLLABORATOR"];
+
+  const now = new Date();
+  const from = new Date(Date.UTC(now.getUTCFullYear(), 0, 1)).toISOString();
+  const to = now.toISOString();
+
   let user: any = null;
+  let isOrgAccount = false;
+  try {
+    const data = await postGraphQL(QUERY_PROFILE, {
+      login: username,
+      from,
+      to,
+      isOrg,
+    });
+    user = data.user;
+    if (!user) throw new NotFoundError();
+  } catch (err) {
+    if (err instanceof NotFoundError) {
+      const data = await postGraphQL(QUERY_ORG, {
+        login: username,
+      });
+      user = data.organization;
+      if (!user) throw new NotFoundError();
+      isOrgAccount = true;
+    } else throw err;
+  }
+
+  const langMap: LangMap = new Map();
+  const seenRepos = new Set<string>();
   let stars = 0;
-  let repos = 0;
-  let page = 0;
-
-  while (hasNext && page++ < MAX_PAGES) {
-    const body = await postGraphQL(query, { login: username, cursor, from, to });
-    if (!body.data?.user) throw new NotFoundError("User not found");
-    if (!user) user = body.data.user;
-
-    const r = body.data.user.repositories;
-    if (!repos) repos = r?.totalCount || 0;
-    for (const node of r?.nodes || []) {
-      stars += node?.stargazers?.totalCount || 0;
-      if (langMap) accumulateLanguageEdges(node?.languages?.edges || [], langMap);
+  let reposCount = 0;
+
+  const processNode = (n: any, scopeCheck: boolean) => {
+    if (!n || !n.nameWithOwner || seenRepos.has(n.nameWithOwner)) return;
+    if (
+      scopeCheck &&
+      n.owner?.__typename === "Organization" &&
+      orgsSet &&
+      !orgsSet.has(n.owner.login.toLowerCase())
+    )
+      return;
+    seenRepos.add(n.nameWithOwner);
+    stars += n.stargazers?.totalCount || 0;
+    reposCount++;
+    if (fetchLangs) accLangs(n.languages?.edges, langMap);
+  };
+
+  const getConnection = (data: any, query: string) =>
+    data.user
+      ? query.includes("repositoriesContributedTo")
+        ? data.user.repositoriesContributedTo
+        : data.user.repositories
+      : data.organization?.repositories;
+
+  const traversePages = async (query: string, scopeCheck: boolean) => {
+    let cursor: string | null = null;
+    let page = 0;
+    let hasNext = true;
+
+    while (hasNext && page++ < MAX_PAGES) {
+      const data = await postGraphQL(query, {
+        login: username,
+        cursor,
+        pageSize: REPO_PAGE_SIZE,
+        fetchLangs,
+        affiliations,
+      });
+      const nextConn = getConnection(data, query);
+      for (const n of nextConn?.nodes || []) processNode(n, scopeCheck);
+      hasNext = nextConn?.pageInfo?.hasNextPage;
+      cursor = nextConn?.pageInfo?.endCursor;
+      if (hasNext && !cursor) break;
     }
+  };
 
-    hasNext = Boolean(r?.pageInfo?.hasNextPage);
-    cursor = r?.pageInfo?.endCursor ?? null;
-    if (!r?.nodes?.length) hasNext = false;
+  const tasks: Promise<void>[] = [];
+  if (!isOrgAccount) {
+    if (isPersonal) tasks.push(traversePages(QUERY_PAGINATE_USER_REPOS, false));
+    if (isOrg) tasks.push(traversePages(QUERY_PAGINATE_ORG_CONTRIBS, true));
+  } else {
+    tasks.push(traversePages(QUERY_PAGINATE_ORG_REPOS, false));
   }
 
-  return { user, stars, repos, langMap };
-}
+  const [avatarDataUrl] = await Promise.all([fetchAvatarAsBase64(user.avatarUrl), ...tasks]);
 
-/**
- * Fetches repos the user actually contributed to (commits, PRs, or owns)
- * that are owned by organizations — not the user themselves.
- * Filters by org login when `orgsFilter` is non-empty.
- */
-async function fetchOrgContributions(
-  username: string,
-  langs: boolean,
-  orgsFilter: string[],
-): Promise<RepoResult> {
-  const query = buildOrgContribsQuery(langs);
-  const langMap: LangMap | null = langs ? new Map() : null;
-  const filterSet = orgsFilter.length > 0 ? new Set(orgsFilter) : null;
-  let hasNext = true;
-  let cursor: string | null = null;
-  let stars = 0;
-  let repos = 0;
-  let page = 0;
-
-  while (hasNext && page++ < MAX_PAGES) {
-    const body = await postGraphQL(query, { login: username, cursor });
-    if (!body.data?.user) throw new NotFoundError("User not found");
-
-    const c = body.data.user.repositoriesContributedTo;
-    for (const repo of c?.nodes || []) {
-      if (repo?.owner?.__typename !== "Organization") continue;
-      if (filterSet && !filterSet.has(repo.owner.login.toLowerCase())) continue;
-      stars += repo.stargazers?.totalCount || 0;
-      repos += 1;
-      if (langMap) accumulateLanguageEdges(repo.languages?.edges || [], langMap);
-    }
+  let commits = 0;
+  let prs = 0;
+  let issues = 0;
 
-    hasNext = Boolean(c?.pageInfo?.hasNextPage);
-    cursor = c?.pageInfo?.endCursor || null;
-    if (!c?.nodes?.length) hasNext = false;
+  if (!isOrgAccount) {
+    const c = user.contributionsCollection;
+    if (opts.scope === "org") {
+      commits = sumContributions(c?.commitContributionsByRepository, orgsSet);
+      prs = sumContributions(c?.pullRequestContributionsByRepository, orgsSet);
+      issues = sumContributions(c?.issueContributionsByRepository, orgsSet);
+    } else {
+      commits = c?.totalCommitContributions || 0;
+      prs =
+        (user.openPRs?.totalCount || 0) +
+        (user.closedPRs?.totalCount || 0) +
+        (user.mergedPRs?.totalCount || 0);
+      issues = (user.openIssues?.totalCount || 0) + (user.closedIssues?.totalCount || 0);
+    }
   }
 
-  return { stars, repos, langMap };
+  const languages = Array.from(langMap.entries())
+    .map(([name, { size, color }]) => ({ name, size, color }))
+    .sort((a, b) => b.size - a.size)
+    .slice(0, opts.langCount || 5);
+
+  return {
+    user: {
+      login: user.login,
+      name: user.name,
+      avatarUrl: avatarDataUrl,
+      bio: user.bio || user.description,
+      pronouns: user.pronouns,
+      twitter: user.twitterUsername,
+    },
+    stats: { stars, repos: reposCount, prs, issues, commits },
+    languages,
+  };
 }
 
 export async function getProfileData(
   username: string,
   opts: FetchOptions = {},
 ): Promise<ProfileData> {
-  const includeLanguages = opts.includeLanguages ?? true;
-  const langCount = Math.min(10, Math.max(1, opts.langCount ?? 5));
-  const scope = normalizeScope(opts.scope);
-  const forceRefresh = opts.forceRefresh ?? false;
-  const orgs = Array.from(new Set((opts.orgs || []).map((org) => org.trim()).filter(Boolean)))
-    .map((org) => org.toLowerCase())
-    .sort();
-  const cacheRaw = `v2:${username}:${scope}:${includeLanguages ? "langs" : "nolangs"}:${langCount}:${orgs.join("|")}`;
-  const cacheKey = buildCacheKey(cacheRaw);
-
-  if (!forceRefresh) {
-    const cached = getCacheState(cacheKey);
-    if (cached && !cached.stale) return cached.value;
-
-    if (cached?.stale) {
-      const existingStale = cache.get(cacheKey);
-      if (existingStale && !existingStale.inFlight) {
-        existingStale.inFlight = (async () => {
-          try {
-            const refreshed = await getProfileData(username, {
-              includeLanguages,
-              langCount,
-              scope,
-              orgs,
-              forceRefresh: true,
-            });
-            return refreshed;
-          } catch {
-            return cached.value;
-          } finally {
-            const current = cache.get(cacheKey);
-            if (current) current.inFlight = undefined;
-          }
-        })();
-      }
-      return cached.value;
+  const norm = normalizeUsername(username);
+  const orgs = normalizeOrgFilters(opts.orgs);
+  const cacheKey = Bun.hash(
+    `v${CACHE_VERSION}:${norm}:${opts.scope || "personal"}:${opts.affiliations || "affiliated"}:${opts.includeLanguages !== false}:${opts.langCount || 5}:${orgs.join("|")}`,
+  ).toString(36);
+
+  if (!opts.forceRefresh) {
+    const mem = memCache.get(cacheKey);
+    const now = Date.now();
+    if (mem && mem.expiresAt > now) {
+      if (mem.staleAt <= now && !refreshInFlight.has(cacheKey))
+        triggerBackgroundRefresh(username, opts, cacheKey);
+      return mem.data;
     }
-  }
 
-  const redis = await getRedis();
-  if (!forceRefresh && redis) {
-    try {
-      const redisValue = await redis.get<ProfileData>(`profile:${cacheKey}`);
-      if (redisValue) {
-        setCache(cacheKey, redisValue);
-        return redisValue;
-      }
-    } catch {}
+    const cached = await readRedisCache(cacheKey, now);
+    if (cached) {
+      setMemoryCache(cacheKey, cached);
+      if (cached.staleAt <= now && !refreshInFlight.has(cacheKey))
+        triggerBackgroundRefresh(username, opts, cacheKey);
+      return cached.data;
+    }
   }
 
-  const existing = cache.get(cacheKey);
-  if (!forceRefresh && existing?.inFlight) return existing.inFlight;
-
-  const inFlight = (async () => {
-    try {
-      const now = new Date();
-      const from = new Date(Date.UTC(now.getUTCFullYear(), 0, 1)).toISOString();
-      const to = now.toISOString();
-
-      // Parallel data fetching based on scope
-      let user: any;
-      let pStars = 0,
-        pRepos = 0,
-        oStars = 0,
-        oRepos = 0;
-      let pLangs: LangMap | null = null;
-      let oLangs: LangMap | null = null;
-
-      if (scope === "personal") {
-        const r = await fetchPersonalRepos(username, includeLanguages, from, to);
-        user = r.user;
-        pStars = r.stars;
-        pRepos = r.repos;
-        pLangs = r.langMap;
-      } else if (scope === "org") {
-        const [meta, org] = await Promise.all([
-          fetchUserMeta(username, from, to),
-          fetchOrgContributions(username, includeLanguages, orgs),
-        ]);
-        user = meta;
-        oStars = org.stars;
-        oRepos = org.repos;
-        oLangs = org.langMap;
-      } else {
-        // scope === "all" — fetch personal + org in parallel
-        const [personal, org] = await Promise.all([
-          fetchPersonalRepos(username, includeLanguages, from, to),
-          fetchOrgContributions(username, includeLanguages, orgs),
-        ]);
-        user = personal.user;
-        pStars = personal.stars;
-        pRepos = personal.repos;
-        pLangs = personal.langMap;
-        oStars = org.stars;
-        oRepos = org.repos;
-        oLangs = org.langMap;
-      }
-
-      const languages = includeLanguages
-        ? buildLanguageStats(mergeLangMaps(pLangs, oLangs), langCount)
-        : [];
-
-      // Embed avatar as base64 data URI for reliable rendering in <img> contexts
-      const avatarSized = user.avatarUrl + (user.avatarUrl.includes("?") ? "&" : "?") + "s=200";
-      const avatarDataUrl = await fetchAvatarDataUrl(avatarSized);
-
-      const profile: ProfileData = {
-        user: {
-          login: user.login,
-          name: user.name,
-          avatarUrl: avatarDataUrl,
-          bio: user.bio,
-          pronouns: user.pronouns,
-          twitter: user.twitterUsername,
-        },
-        stats: {
-          stars: scope === "org" ? oStars : pStars + oStars,
-          repos: scope === "org" ? oRepos : pRepos + oRepos,
-          prs:
-            (user.openPRs?.totalCount || 0) +
-            (user.closedPRs?.totalCount || 0) +
-            (user.mergedPRs?.totalCount || 0),
-          issues: (user.openIssues?.totalCount || 0) + (user.closedIssues?.totalCount || 0),
-          commits: user.contributionsCollection?.totalCommitContributions || 0,
-        },
-        languages,
-      };
-
-      setCache(cacheKey, profile);
-      if (redis) {
-        try {
-          await redis.set(`profile:${cacheKey}`, profile, {
-            ex: CACHE_FRESH_SECONDS + CACHE_STALE_SECONDS,
-          });
-        } catch {}
-      }
-      return profile;
-    } catch (err) {
-      cache.delete(cacheKey);
-      throw err;
-    }
-  })();
+  if (inFlight.has(cacheKey)) return inFlight.get(cacheKey)!;
 
-  cache.set(cacheKey, {
-    staleAt: Date.now() + CACHE_FRESH_SECONDS * 1000,
-    expiresAt: Date.now() + (CACHE_FRESH_SECONDS + CACHE_STALE_SECONDS) * 1000,
-    inFlight,
-  });
-  return inFlight;
+  const promise = directFetch(username, opts)
+    .then((data) => saveProfileCache(cacheKey, data))
+    .finally(() => {
+      inFlight.delete(cacheKey);
+    });
+
+  inFlight.set(cacheKey, promise);
+  return promise;
+}
+
+function triggerBackgroundRefresh(username: string, opts: FetchOptions, cacheKey: string) {
+  if (refreshInFlight.has(cacheKey)) return;
+  refreshInFlight.add(cacheKey);
+
+  void directFetch(username, { ...opts, forceRefresh: true })
+    .then((data) => saveProfileCache(cacheKey, data))
+    .catch(() => {})
+    .finally(() => {
+      refreshInFlight.delete(cacheKey);
+    });
 }