@jgengine/github 0.1.0

package/dist/calendar.js

@@ -0,0 +1,66 @@
+export const WEEKS = 53;
+export const DAYS = 7;
+export const CELL_COUNT = WEEKS * DAYS;
+export const WEEKDAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+export const MONTH_NAMES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const ANCHOR = Date.UTC(2024, 0, 7);
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** GitHub's quartile bucketing of a day's contribution count (0 = none … 4 = most).
+ * @internal
+ */
+export function levelForCount(count) {
+    if (count <= 0)
+        return 0;
+    if (count <= 2)
+        return 1;
+    if (count <= 5)
+        return 2;
+    if (count <= 9)
+        return 3;
+    return 4;
+}
+/** @internal */
+export function dateOf(index) {
+    return new Date(ANCHOR + index * 86400000);
+}
+/** @internal */
+export function dateLabel(index) {
+    return labelFromISO(dateOf(index).toISOString().slice(0, 10));
+}
+/** @internal */
+export function labelFromISO(iso) {
+    const d = new Date(`${iso}T00:00:00Z`);
+    return `${WEEKDAY_NAMES[d.getUTCDay()]}, ${MONTH_NAMES[d.getUTCMonth()]} ${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+/** Deterministic plausible contribution year for demos / offline fallback.
+ * @internal
+ */
+export function generateYear(seed) {
+    const rng = mulberry32(seed);
+    const seasonPhase = rng() * Math.PI * 2;
+    const cells = [];
+    let streakHeat = 0;
+    for (let week = 0; week < WEEKS; week += 1) {
+        const season = 0.5 + 0.5 * Math.sin(seasonPhase + (week / WEEKS) * Math.PI * 2);
+        streakHeat = rng() < 0.16 ? 1.6 + rng() * 2.2 : streakHeat * 0.72;
+        for (let weekday = 0; weekday < DAYS; weekday += 1) {
+            const index = week * DAYS + weekday;
+            const weekendDrag = weekday === 0 || weekday === 6 ? 0.35 : 1;
+            const base = season * 5 * weekendDrag + streakHeat * weekendDrag;
+            const jitter = rng() * rng() * 6;
+            const idle = rng() < 0.28 - season * 0.14 ? 0 : 1;
+            const count = Math.max(0, Math.round((base + jitter) * idle));
+            cells.push({ index, week, weekday, count, level: levelForCount(count), label: dateLabel(index) });
+        }
+    }
+    return cells;
+}

package/dist/client.d.ts

@@ -0,0 +1,34 @@
+export interface GitHubClientOptions {
+    /**
+     * Proxy base (e.g. "/api/github") that holds a server-side token and forwards
+     * allowlisted GETs to api.github.com. Required in the browser for private /
+     * authed data and for GraphQL; omit for direct public REST.
+     */
+    endpoint?: string;
+    /** Personal access token for DIRECT calls — server/Node only, never shipped to a browser. */
+    token?: string;
+    /** Injectable fetch (tests, non-browser runtimes). Defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+}
+/** @internal */
+export declare class GitHubError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/**
+ * Minimal transport over the GitHub API. `rest`/`graphql` are the two primitives;
+ * resource helpers (repos, pullRequests, …) are thin functions built on `rest`.
+ * Public reads can go direct; anything private/authed/GraphQL routes through a
+ * proxy endpoint that keeps the token server-side.
+ */
+export interface GitHubClient {
+    rest<T>(path: string): Promise<T>;
+    /**
+     * Direct mode (no `endpoint`): `query` is raw GraphQL text sent with the token.
+     * Proxy mode: `query` is the allowlisted operation name — the server owns the
+     * actual query text, so the browser never transmits free-form GraphQL.
+     */
+    graphql<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
+}
+/** @internal */
+export declare function createGitHub(options?: GitHubClientOptions): GitHubClient;

package/dist/client.js

@@ -0,0 +1,48 @@
+/** @internal */
+export class GitHubError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "GitHubError";
+    }
+}
+const API = "https://api.github.com";
+const REST_HEADERS = { Accept: "application/vnd.github+json", "User-Agent": "jgengine" };
+async function unwrapGraphQL(response) {
+    if (!response.ok)
+        throw new GitHubError(response.status, `GitHub GraphQL failed (${response.status})`);
+    const payload = (await response.json());
+    if (payload.errors?.length)
+        throw new GitHubError(502, payload.errors.map((e) => e.message).join("; "));
+    return payload.data;
+}
+/** @internal */
+export function createGitHub(options = {}) {
+    const doFetch = options.fetchImpl ?? fetch;
+    const { endpoint, token } = options;
+    async function rest(path) {
+        const url = endpoint === undefined ? `${API}${path}` : `${endpoint}?path=${encodeURIComponent(path)}`;
+        const headers = endpoint === undefined && token !== undefined ? { ...REST_HEADERS, Authorization: `Bearer ${token}` } : REST_HEADERS;
+        const response = await doFetch(url, { headers });
+        if (!response.ok)
+            throw new GitHubError(response.status, `GitHub GET ${path} failed (${response.status})`);
+        return (await response.json());
+    }
+    async function graphql(query, variables = {}) {
+        if (endpoint === undefined) {
+            if (token === undefined)
+                throw new GitHubError(401, "GraphQL requires a token (or a proxy endpoint that holds one).");
+            const headers = { ...REST_HEADERS, "Content-Type": "application/json", Authorization: `Bearer ${token}` };
+            const response = await doFetch(`${API}/graphql`, { method: "POST", headers, body: JSON.stringify({ query, variables }) });
+            return unwrapGraphQL(response);
+        }
+        const response = await doFetch(`${endpoint}?op=${encodeURIComponent(query)}`, {
+            method: "POST",
+            headers: { ...REST_HEADERS, "Content-Type": "application/json" },
+            body: JSON.stringify({ variables }),
+        });
+        return unwrapGraphQL(response);
+    }
+    return { rest, graphql };
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { CELL_COUNT, DAYS, WEEKS, WEEKDAY_NAMES, MONTH_NAMES, dateOf, dateLabel, labelFromISO, generateYear, levelForCount, type DayCell, } from "./calendar.js";
+export { summarize, type ContributionStats } from "./analytics.js";
+export { DEFAULT_ENDPOINT, contributions, wireToCells, type ContributionData, type ContributionsWire, type GitHubProfile, } from "./source.js";
+export { createGitHub, GitHubError, type GitHubClient, type GitHubClientOptions } from "./client.js";
+export * from "./resources/repos.js";
+export * from "./resources/issues.js";
+export * from "./resources/pulls.js";
+export * from "./resources/actions.js";
+export * from "./resources/activity.js";
+export * from "./resources/search.js";
+export * from "./resources/users.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { CELL_COUNT, DAYS, WEEKS, WEEKDAY_NAMES, MONTH_NAMES, dateOf, dateLabel, labelFromISO, generateYear, levelForCount, } from "./calendar.js";
+export { summarize } from "./analytics.js";
+export { DEFAULT_ENDPOINT, contributions, wireToCells, } from "./source.js";
+export { createGitHub, GitHubError } from "./client.js";
+export * from "./resources/repos.js";
+export * from "./resources/issues.js";
+export * from "./resources/pulls.js";
+export * from "./resources/actions.js";
+export * from "./resources/activity.js";
+export * from "./resources/search.js";
+export * from "./resources/users.js";

package/dist/resources/actions.d.ts

@@ -0,0 +1,26 @@
+import type { GitHubClient } from "../client.js";
+export interface Workflow {
+    id: number;
+    name: string;
+    state: string;
+    path: string;
+}
+export interface WorkflowRun {
+    id: number;
+    name: string | null;
+    status: string;
+    conclusion: string | null;
+    event: string;
+    headBranch: string | null;
+    runNumber: number;
+    createdAt: string;
+    url: string;
+}
+/** List the workflow definitions configured on a repository. */
+export declare function workflows(gh: GitHubClient, owner: string, name: string): Promise<Workflow[]>;
+export interface WorkflowRunsOptions {
+    perPage?: number;
+    branch?: string;
+}
+/** List recent workflow runs (CI history) for a repository. */
+export declare function workflowRuns(gh: GitHubClient, owner: string, name: string, opts?: WorkflowRunsOptions): Promise<WorkflowRun[]>;

package/dist/resources/actions.js

@@ -0,0 +1,26 @@
+function clampPerPage(perPage) {
+    return Math.min(perPage ?? 30, 100);
+}
+/** List the workflow definitions configured on a repository. */
+export async function workflows(gh, owner, name) {
+    const raw = await gh.rest(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/actions/workflows`);
+    return raw.workflows.map((w) => ({ id: w.id, name: w.name, state: w.state, path: w.path }));
+}
+/** List recent workflow runs (CI history) for a repository. */
+export async function workflowRuns(gh, owner, name, opts = {}) {
+    const params = new URLSearchParams({ per_page: String(clampPerPage(opts.perPage)) });
+    if (opts.branch !== undefined)
+        params.set("branch", opts.branch);
+    const raw = await gh.rest(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/actions/runs?${params.toString()}`);
+    return raw.workflow_runs.map((r) => ({
+        id: r.id,
+        name: r.name,
+        status: r.status,
+        conclusion: r.conclusion,
+        event: r.event,
+        headBranch: r.head_branch,
+        runNumber: r.run_number,
+        createdAt: r.created_at,
+        url: r.html_url,
+    }));
+}

package/dist/resources/activity.d.ts

@@ -0,0 +1,24 @@
+import { type GitHubClient } from "../client.js";
+export interface ActivityEvent {
+    type: string;
+    repo: string;
+    createdAt: string;
+    action?: string;
+}
+export interface EventsOptions {
+    perPage?: number;
+}
+/** A user's public activity feed (pushes, issue/PR actions, stars, forks, …). */
+export declare function events(gh: GitHubClient, user: string, opts?: EventsOptions): Promise<ActivityEvent[]>;
+export interface CommitActivityWeek {
+    weekStart: number;
+    total: number;
+    days: number[];
+}
+/**
+ * Weekly commit counts for the last year. GitHub computes these stats
+ * asynchronously and may respond 202 with an empty body while the cache
+ * warms up; when the parsed payload isn't an array, this returns `[]`
+ * rather than throwing.
+ */
+export declare function commitActivity(gh: GitHubClient, owner: string, name: string): Promise<CommitActivityWeek[]>;

package/dist/resources/activity.js

@@ -0,0 +1,36 @@
+import { GitHubError } from "../client.js";
+function clampPerPage(perPage) {
+    return Math.min(perPage ?? 30, 100);
+}
+/** A user's public activity feed (pushes, issue/PR actions, stars, forks, …). */
+export async function events(gh, user, opts = {}) {
+    const params = new URLSearchParams({ per_page: String(clampPerPage(opts.perPage)) });
+    const raw = await gh.rest(`/users/${encodeURIComponent(user)}/events?${params.toString()}`);
+    return raw.map((e) => {
+        const summary = { type: e.type ?? "unknown", repo: e.repo.name, createdAt: e.created_at ?? "" };
+        const action = e.payload?.action;
+        if (action !== undefined)
+            summary.action = action;
+        return summary;
+    });
+}
+/**
+ * Weekly commit counts for the last year. GitHub computes these stats
+ * asynchronously and may respond 202 with an empty body while the cache
+ * warms up; when the parsed payload isn't an array, this returns `[]`
+ * rather than throwing.
+ */
+export async function commitActivity(gh, owner, name) {
+    let raw;
+    try {
+        raw = await gh.rest(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/stats/commit_activity`);
+    }
+    catch (err) {
+        if (err instanceof GitHubError)
+            throw err;
+        return [];
+    }
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map((w) => ({ weekStart: w.week, total: w.total, days: w.days }));
+}

package/dist/resources/issues.d.ts

@@ -0,0 +1,42 @@
+import type { GitHubClient } from "../client.js";
+export interface IssueSummary {
+    number: number;
+    title: string;
+    state: string;
+    comments: number;
+    isPullRequest: boolean;
+    createdAt: string;
+    closedAt: string | null;
+    author: string | null;
+    labels: string[];
+    url: string;
+}
+interface RawLabel {
+    name?: string;
+}
+export interface RawIssue {
+    number: number;
+    title: string;
+    state: string;
+    comments: number;
+    pull_request?: unknown;
+    created_at: string;
+    closed_at: string | null;
+    user: {
+        login: string;
+    } | null;
+    labels?: (string | RawLabel)[];
+    html_url: string;
+}
+export declare function toIssueSummary(raw: RawIssue): IssueSummary;
+export interface IssuesOptions {
+    state?: "open" | "closed" | "all";
+    perPage?: number;
+}
+/**
+ * List issues on a repository. GitHub's `/issues` endpoint also returns pull
+ * requests (an item is a PR when it carries a `pull_request` key) — that's
+ * reflected in `isPullRequest`, and `comments` is the item's comment count.
+ */
+export declare function issues(gh: GitHubClient, owner: string, name: string, opts?: IssuesOptions): Promise<IssueSummary[]>;
+export {};

package/dist/resources/issues.js

@@ -0,0 +1,30 @@
+function clampPerPage(perPage) {
+    return Math.min(perPage ?? 30, 100);
+}
+function labelName(label) {
+    return typeof label === "string" ? label : label.name;
+}
+export function toIssueSummary(raw) {
+    return {
+        number: raw.number,
+        title: raw.title,
+        state: raw.state,
+        comments: raw.comments,
+        isPullRequest: raw.pull_request !== undefined,
+        createdAt: raw.created_at,
+        closedAt: raw.closed_at,
+        author: raw.user?.login ?? null,
+        labels: (raw.labels ?? []).map(labelName).filter((n) => n !== undefined),
+        url: raw.html_url,
+    };
+}
+/**
+ * List issues on a repository. GitHub's `/issues` endpoint also returns pull
+ * requests (an item is a PR when it carries a `pull_request` key) — that's
+ * reflected in `isPullRequest`, and `comments` is the item's comment count.
+ */
+export async function issues(gh, owner, name, opts = {}) {
+    const params = new URLSearchParams({ per_page: String(clampPerPage(opts.perPage)), state: opts.state ?? "open" });
+    const raw = await gh.rest(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/issues?${params.toString()}`);
+    return raw.map(toIssueSummary);
+}

package/dist/resources/pulls.d.ts

@@ -0,0 +1,46 @@
+/**
+ * NOTE: GitHub's pull-request LIST endpoint (`/repos/{owner}/{repo}/pulls`) does
+ * NOT include a comment count on each item. Callers that want comments-per-PR
+ * should use `issues()` from ./issues instead — the issues endpoint includes
+ * pull requests and reports `comments` on every item.
+ */
+import type { GitHubClient } from "../client.js";
+export interface PullRequestSummary {
+    number: number;
+    title: string;
+    state: string;
+    draft: boolean;
+    merged: boolean;
+    createdAt: string;
+    mergedAt: string | null;
+    author: string | null;
+    headRef: string;
+    baseRef: string;
+    url: string;
+}
+interface RawPullRequest {
+    number: number;
+    title: string;
+    state: string;
+    draft: boolean;
+    merged_at: string | null;
+    created_at: string;
+    user: {
+        login: string;
+    } | null;
+    head: {
+        ref: string;
+    };
+    base: {
+        ref: string;
+    };
+    html_url: string;
+}
+export declare function toPullRequestSummary(raw: RawPullRequest): PullRequestSummary;
+export interface PullRequestsOptions {
+    state?: "open" | "closed" | "all";
+    perPage?: number;
+}
+/** List pull requests on a repository. See the module note re: comment counts. */
+export declare function pullRequests(gh: GitHubClient, owner: string, name: string, opts?: PullRequestsOptions): Promise<PullRequestSummary[]>;
+export {};

package/dist/resources/pulls.js

@@ -0,0 +1,24 @@
+function clampPerPage(perPage) {
+    return Math.min(perPage ?? 30, 100);
+}
+export function toPullRequestSummary(raw) {
+    return {
+        number: raw.number,
+        title: raw.title,
+        state: raw.state,
+        draft: raw.draft,
+        merged: raw.merged_at !== null,
+        createdAt: raw.created_at,
+        mergedAt: raw.merged_at,
+        author: raw.user?.login ?? null,
+        headRef: raw.head.ref,
+        baseRef: raw.base.ref,
+        url: raw.html_url,
+    };
+}
+/** List pull requests on a repository. See the module note re: comment counts. */
+export async function pullRequests(gh, owner, name, opts = {}) {
+    const params = new URLSearchParams({ per_page: String(clampPerPage(opts.perPage)), state: opts.state ?? "open" });
+    const raw = await gh.rest(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/pulls?${params.toString()}`);
+    return raw.map(toPullRequestSummary);
+}

package/dist/resources/repos.d.ts

@@ -0,0 +1,55 @@
+import type { GitHubClient } from "../client.js";
+export interface RepoSummary {
+    name: string;
+    fullName: string;
+    description: string | null;
+    stars: number;
+    forks: number;
+    watchers: number;
+    openIssues: number;
+    language: string | null;
+    topics: string[];
+    license: string | null;
+    archived: boolean;
+    isFork: boolean;
+    createdAt: string;
+    pushedAt: string | null;
+    url: string;
+}
+export interface RawRepo {
+    name: string;
+    full_name: string;
+    description: string | null;
+    stargazers_count: number;
+    forks_count: number;
+    watchers_count: number;
+    open_issues_count: number;
+    language: string | null;
+    topics?: string[];
+    license: {
+        name: string;
+    } | null;
+    archived: boolean;
+    fork: boolean;
+    created_at: string;
+    pushed_at: string | null;
+    html_url: string;
+}
+export declare function toRepoSummary(raw: RawRepo): RepoSummary;
+export interface ReposOptions {
+    sort?: "updated" | "pushed" | "stars";
+    perPage?: number;
+}
+/** List a user's repositories, mapped down to a lean summary shape. */
+export declare function repos(gh: GitHubClient, user: string, opts?: ReposOptions): Promise<RepoSummary[]>;
+/** Fetch a single repository by owner/name. */
+export declare function repo(gh: GitHubClient, owner: string, name: string): Promise<RepoSummary>;
+/** Bytes of code per language, as reported by GitHub's linguist pass. */
+export declare function languages(gh: GitHubClient, owner: string, name: string): Promise<Record<string, number>>;
+export interface LanguageShare {
+    language: string;
+    bytes: number;
+    share: number;
+}
+/** Rank a language→bytes map, attaching each entry's share of the total. */
+export declare function topLanguages(bytes: Record<string, number>, n?: number): LanguageShare[];

package/dist/resources/repos.js

@@ -0,0 +1,47 @@
+function clampPerPage(perPage) {
+    return Math.min(perPage ?? 30, 100);
+}
+export function toRepoSummary(raw) {
+    return {
+        name: raw.name,
+        fullName: raw.full_name,
+        description: raw.description,
+        stars: raw.stargazers_count,
+        forks: raw.forks_count,
+        watchers: raw.watchers_count,
+        openIssues: raw.open_issues_count,
+        language: raw.language,
+        topics: raw.topics ?? [],
+        license: raw.license?.name ?? null,
+        archived: raw.archived,
+        isFork: raw.fork,
+        createdAt: raw.created_at,
+        pushedAt: raw.pushed_at,
+        url: raw.html_url,
+    };
+}
+/** List a user's repositories, mapped down to a lean summary shape. */
+export async function repos(gh, user, opts = {}) {
+    const params = new URLSearchParams({ per_page: String(clampPerPage(opts.perPage)) });
+    if (opts.sort !== undefined)
+        params.set("sort", opts.sort);
+    const raw = await gh.rest(`/users/${encodeURIComponent(user)}/repos?${params.toString()}`);
+    return raw.map(toRepoSummary);
+}
+/** Fetch a single repository by owner/name. */
+export async function repo(gh, owner, name) {
+    const raw = await gh.rest(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`);
+    return toRepoSummary(raw);
+}
+/** Bytes of code per language, as reported by GitHub's linguist pass. */
+export async function languages(gh, owner, name) {
+    return gh.rest(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/languages`);
+}
+/** Rank a language→bytes map, attaching each entry's share of the total. */
+export function topLanguages(bytes, n = 5) {
+    const total = Object.values(bytes).reduce((sum, value) => sum + value, 0);
+    return Object.entries(bytes)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, n)
+        .map(([language, value]) => ({ language, bytes: value, share: total === 0 ? 0 : value / total }));
+}

package/dist/resources/search.d.ts

@@ -0,0 +1,14 @@
+import type { GitHubClient } from "../client.js";
+import { type IssueSummary } from "./issues.js";
+import { type RepoSummary } from "./repos.js";
+export interface SearchResult<T> {
+    totalCount: number;
+    incomplete: boolean;
+    items: T[];
+}
+/** Join qualifier parts (skipping undefined values) into a GitHub search query string. */
+export declare function buildQuery(parts: Record<string, string | number | undefined>): string;
+/** Search issues and pull requests. Reuses the issues() mapping since search returns the same item shape. */
+export declare function searchIssues(gh: GitHubClient, query: string): Promise<SearchResult<IssueSummary>>;
+/** Search repositories. */
+export declare function searchRepos(gh: GitHubClient, query: string): Promise<SearchResult<RepoSummary>>;

package/dist/resources/search.js

@@ -0,0 +1,19 @@
+import { toIssueSummary } from "./issues.js";
+import { toRepoSummary } from "./repos.js";
+/** Join qualifier parts (skipping undefined values) into a GitHub search query string. */
+export function buildQuery(parts) {
+    return Object.entries(parts)
+        .filter((entry) => entry[1] !== undefined)
+        .map(([key, value]) => `${key}:${value}`)
+        .join(" ");
+}
+/** Search issues and pull requests. Reuses the issues() mapping since search returns the same item shape. */
+export async function searchIssues(gh, query) {
+    const raw = await gh.rest(`/search/issues?q=${encodeURIComponent(query)}`);
+    return { totalCount: raw.total_count, incomplete: raw.incomplete_results, items: raw.items.map(toIssueSummary) };
+}
+/** Search repositories. */
+export async function searchRepos(gh, query) {
+    const raw = await gh.rest(`/search/repositories?q=${encodeURIComponent(query)}`);
+    return { totalCount: raw.total_count, incomplete: raw.incomplete_results, items: raw.items.map(toRepoSummary) };
+}

package/dist/resources/users.d.ts

@@ -0,0 +1,17 @@
+import type { GitHubClient } from "../client.js";
+export interface UserProfile {
+    login: string;
+    name: string | null;
+    bio: string | null;
+    company: string | null;
+    location: string | null;
+    blog: string | null;
+    followers: number;
+    following: number;
+    publicRepos: number;
+    avatarUrl: string;
+    createdAt: string;
+    hireable: boolean | null;
+}
+/** Fetch a public user profile. */
+export declare function user(gh: GitHubClient, login: string): Promise<UserProfile>;

package/dist/resources/users.js

@@ -0,0 +1,18 @@
+/** Fetch a public user profile. */
+export async function user(gh, login) {
+    const raw = await gh.rest(`/users/${encodeURIComponent(login)}`);
+    return {
+        login: raw.login,
+        name: raw.name,
+        bio: raw.bio,
+        company: raw.company,
+        location: raw.location,
+        blog: raw.blog,
+        followers: raw.followers,
+        following: raw.following,
+        publicRepos: raw.public_repos,
+        avatarUrl: raw.avatar_url,
+        createdAt: raw.created_at,
+        hireable: raw.hireable,
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,47 @@
+import type { ContributionsWire } from "./wire.js";
+export type { ContributionsWire } from "./wire.js";
+/** Thrown by resolveContributions when the user does not exist (→ 404). */
+export declare class GitHubUserNotFoundError extends Error {
+}
+export declare function parseContributionsHtml(html: string): {
+    date: string;
+    count: number;
+    weekday: number;
+}[];
+/** Server-side: fetch a user's contribution calendar via GraphQL (with token) or HTML scrape. */
+export declare function resolveContributions(user: string, options?: {
+    token?: string;
+}): Promise<ContributionsWire>;
+/**
+ * Turnkey proxy handler — mount at any route in any Web-`Response` server (Nitro,
+ * workers, Deno). Reads `?user=`, validates, proxies GitHub, returns JSON + CORS.
+ */
+export declare function githubContributionsHandler(options?: {
+    token?: string;
+}): (request: Request) => Promise<Response>;
+export interface GitHubProxyOptions {
+    /** Server-side token; forwarded as `Authorization: Bearer` so private/authed reads work. */
+    token?: string;
+    /**
+     * REST path allowlist — return true to forward a `?path=` GET. Every path is
+     * rejected (403) unless this says otherwise; omitting it denies everything.
+     * There is no "allow all" default, so a bare mount can never become an open proxy.
+     */
+    allowPath?: (path: string) => boolean;
+    /**
+     * GraphQL allowlist, keyed by operation name, holding the exact query text the
+     * server sends upstream for that name. Callers pick an `?op=` name and supply
+     * only `variables`; they never send query text, so an unlisted or forged query
+     * can't reach GitHub. Omitting this disables GraphQL entirely.
+     */
+    graphqlOperations?: Record<string, string>;
+    /** Injectable fetch (tests, non-browser runtimes). Defaults to global fetch. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Named-operation GitHub proxy: forwards only the REST paths and GraphQL
+ * operations the caller explicitly allowlists, using the server-side token.
+ * Clients never supply raw GraphQL text or an unconstrained path — a bare
+ * mount with no `allowPath`/`graphqlOperations` forwards nothing at all.
+ */
+export declare function githubProxyHandler(options?: GitHubProxyOptions): (request: Request) => Promise<Response>;