github-pro-mcp 0.0.2 → 0.0.3

package/dist/tools/pull_requests.js

@@ -1,127 +0,0 @@
-import * as z from "zod/v4";
-import { createClient } from "../client.js";
-import { handleGitHubError } from "../utils/errors.js";
-import { validatePinnedOwnerRepo } from "../utils/validation.js";
-import { OwnerRepoSchema, PullNumberSchema, PrIncludeFlagsSchema } from "../utils/types.js";
-export function registerPullRequestRead(server) {
-    server.registerTool("pull_request_read", {
-        description: "Get details of a pull request. Optionally include commits and reviews. Each include_* flag makes additional API calls.",
-        inputSchema: OwnerRepoSchema.extend({
-            pull_number: PullNumberSchema,
-            include_commits: PrIncludeFlagsSchema.shape.include_commits,
-            include_reviews: PrIncludeFlagsSchema.shape.include_reviews,
-            max_commits: z.number().int().positive().optional().describe("Maximum number of commits to return (default: all)"),
-            max_reviews: z.number().int().positive().optional().describe("Maximum number of reviews to return (default: all)"),
-        }),
-    }, async ({ owner, repo, pull_number, include_commits, include_reviews, max_commits, max_reviews }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data: pr } = await octokit.rest.pulls.get({ owner, repo, pull_number });
-            const result = {
-                number: pr.number,
-                title: pr.title,
-                body: pr.body,
-                state: pr.state,
-                html_url: pr.html_url,
-                draft: pr.draft,
-                mergeable: pr.mergeable,
-                merged: pr.merged,
-                created_at: pr.created_at,
-                updated_at: pr.updated_at,
-                closed_at: pr.closed_at,
-                merged_at: pr.merged_at,
-                user: { login: pr.user?.login, avatar_url: pr.user?.avatar_url },
-                head: { ref: pr.head.ref, sha: pr.head.sha, repo: pr.head.repo?.full_name ?? null },
-                base: { ref: pr.base.ref, sha: pr.base.sha, repo: pr.base.repo?.full_name ?? null },
-            };
-            if (include_commits) {
-                const { data: commits } = await octokit.rest.pulls.listCommits({ owner, repo, pull_number, per_page: max_commits ?? 100 });
-                result.commits = commits.map((c) => ({
-                    sha: c.sha,
-                    message: c.commit.message.split("\n")[0],
-                    author: c.commit.author?.name,
-                    date: c.commit.author?.date,
-                }));
-            }
-            if (include_reviews) {
-                const { data: reviews } = await octokit.rest.pulls.listReviews({ owner, repo, pull_number, per_page: max_reviews ?? 100 });
-                result.reviews = reviews.map((r) => ({
-                    id: r.id,
-                    state: r.state,
-                    user: r.user?.login,
-                    body: r.body,
-                    submitted_at: r.submitted_at,
-                }));
-            }
-            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerPullRequestCreate(server) {
-    server.registerTool("pull_request_create", {
-        description: "Create a new pull request in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            title: z.string().min(1).describe("Pull request title"),
-            head: z.string().min(1).describe("Branch containing changes"),
-            base: z.string().min(1).describe("Branch to merge into"),
-            body: z.string().optional().describe("Pull request description"),
-            draft: z.boolean().optional().default(false).describe("Create as draft pull request"),
-        }),
-    }, async ({ owner, repo, title, head, base, body, draft }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.pulls.create({ owner, repo, title, head, base, body, draft });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            number: data.number,
-                            title: data.title,
-                            html_url: data.html_url,
-                            state: data.state,
-                            draft: data.draft,
-                            created_at: data.created_at,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerPullRequestMerge(server) {
-    server.registerTool("pull_request_merge", {
-        description: "Merge a pull request in a GitHub repository.",
-        inputSchema: OwnerRepoSchema.extend({
-            pull_number: PullNumberSchema,
-            merge_method: z.enum(["merge", "squash", "rebase"]).optional().default("merge").describe("Merge method — GitHub accepts: merge, squash, rebase"),
-            commit_title: z.string().optional().describe("Title for merge commit"),
-            commit_message: z.string().optional().describe("Extra detail for merge commit"),
-        }),
-    }, async ({ owner, repo, pull_number, merge_method, commit_title, commit_message }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.pulls.merge({ owner, repo, pull_number, merge_method, commit_title, commit_message });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            merged: data.merged,
-                            message: data.message,
-                            sha: data.sha,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}

package/dist/tools/repos.d.ts

@@ -1,9 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerAuthGetCurrentLogin(server: McpServer): void;
-export declare function registerFileGetContent(server: McpServer): void;
-export declare function registerProfileGet(server: McpServer): void;
-export declare function registerOwnerListRepository(server: McpServer): void;
-export declare function registerFileCreateUpdate(server: McpServer): void;
-export declare function registerCodeSearch(server: McpServer): void;
-export declare function registerFileDelete(server: McpServer): void;
-export declare function registerRepositorySearch(server: McpServer): void;

package/dist/tools/repos.js

@@ -1,251 +0,0 @@
-import * as z from "zod/v4";
-import { createClient } from "../client.js";
-import { handleGitHubError } from "../utils/errors.js";
-import { validatePinnedOwnerRepo } from "../utils/validation.js";
-import { OwnerRepoSchema, PaginationSchema, formatRepo } from "../utils/types.js";
-function toBase64(content) {
-    return Buffer.from(content, "utf-8").toString("base64");
-}
-export function registerAuthGetCurrentLogin(server) {
-    server.registerTool("auth_get_current_login", {
-        description: "Get the authenticated GitHub user's profile. Use this to verify your GitHub token and identity.",
-        inputSchema: z.object({}),
-    }, async () => {
-        try {
-            const octokit = createClient();
-            const { data } = await octokit.rest.users.getAuthenticated();
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            login: data.login,
-                            name: data.name,
-                            avatar_url: data.avatar_url,
-                            html_url: data.html_url,
-                            type: data.type,
-                            plan: data.plan?.name ?? null,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerFileGetContent(server) {
-    server.registerTool("file_get_content", {
-        description: "Get the contents of a file from a GitHub repository. Returns the decoded file content as text.",
-        inputSchema: OwnerRepoSchema.extend({
-            path: z.string().min(1).describe("File path within the repository (e.g., 'README.md' or 'src/index.ts')"),
-            ref: z.string().optional().describe("Git branch, tag, or commit SHA (defaults to repository default branch)"),
-        }),
-    }, async ({ owner, repo, path, ref }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.repos.getContent({ owner, repo, path, ref });
-            if (Array.isArray(data)) {
-                return {
-                    content: [{ type: "text", text: `Path "${path}" is a directory, not a file. Use with a file path instead.` }],
-                    isError: true,
-                };
-            }
-            if (!("content" in data)) {
-                return {
-                    content: [{ type: "text", text: `File "${path}" is not a text file.` }],
-                    isError: true,
-                };
-            }
-            const decoded = Buffer.from(data.content, "base64").toString("utf-8");
-            return { content: [{ type: "text", text: decoded }] };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerProfileGet(server) {
-    server.registerTool("profile_get", {
-        description: "Get profile info for any GitHub owner (user or organization). Useful for checking if an owner is an organization before calling organization-only tools like owner_list_issue_field.",
-        inputSchema: z.object({
-            owner: z.string().min(1).describe("Repository owner (user or organization)"),
-        }),
-    }, async ({ owner }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.users.getByUsername({ username: owner });
-            const ud = data;
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            login: ud.login,
-                            name: ud.name,
-                            type: ud.type,
-                            avatar_url: ud.avatar_url,
-                            html_url: ud.html_url,
-                            description: ud.description ?? ud.bio ?? null,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerOwnerListRepository(server) {
-    server.registerTool("owner_list_repository", {
-        description: "List all repositories for a given owner (user or organization). Unlike search_repositories, this returns all repos the token has access to without relevance ranking.",
-        inputSchema: z.object({
-            owner: z.string().min(1).describe("Repository owner (user or organization)"),
-            type: z.enum(["all", "owner", "member"]).optional().default("all").describe("Type of repositories to list (all, owner, member)"),
-            sort: z.enum(["created", "updated", "pushed", "full_name", "name"]).optional().default("created").describe("Sort field"),
-            direction: z.enum(["asc", "desc"]).optional().describe("Sort direction (asc or desc)"),
-            page: PaginationSchema.shape.page,
-            per_page: PaginationSchema.shape.per_page,
-        }),
-    }, async ({ owner, type, sort, direction, page, per_page }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const { data } = await octokit.rest.repos.listForUser({ username: owner, type, sort: sort, direction, page, per_page });
-            return {
-                content: [{ type: "text", text: JSON.stringify(data.map((r) => formatRepo(r)), null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerFileCreateUpdate(server) {
-    server.registerTool("file_create_update", {
-        description: "Create or update a single file in a GitHub repository. Content is base64-encoded automatically. Provide sha when updating an existing file (obtain sha from the previous file_create_update response).",
-        inputSchema: OwnerRepoSchema.extend({
-            path: z.string().min(1).describe("Path where to create/update the file"),
-            content: z.string().min(1).describe("File content (will be base64-encoded automatically)"),
-            message: z.string().min(1).describe("Commit message"),
-            branch: z.string().min(1).describe("Branch to create/update the file in"),
-            sha: z.string().optional().describe("SHA of existing file (required for updates, obtained from file_get_content)"),
-        }),
-    }, async ({ owner, repo, path, content, message, branch, sha }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const response = await octokit.rest.repos.createOrUpdateFileContents({
-                owner, repo, path, content: toBase64(content), message, branch, sha,
-            });
-            const fileData = response.data;
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            commit: {
-                                sha: fileData.commit.sha,
-                                message: fileData.commit.message,
-                                html_url: fileData.commit.html_url,
-                            },
-                            content: {
-                                sha: fileData.content?.sha ?? null,
-                            },
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerCodeSearch(server) {
-    server.registerTool("code_search", {
-        description: "Search for code across GitHub repositories. Supports GitHub search qualifiers like 'repo:...', 'language:...', 'path:...'.",
-        inputSchema: z.object({
-            query: z.string().min(1).max(1000).describe("Search query with GitHub qualifiers, e.g., 'function repo:owner/repo language:python'"),
-            page: PaginationSchema.shape.page,
-            per_page: PaginationSchema.shape.per_page,
-        }),
-    }, async ({ query, page, per_page }) => {
-        try {
-            const octokit = createClient();
-            const { data } = await octokit.rest.search.code({ q: query, page, per_page });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            total_count: data.total_count,
-                            items: data.items.map((f) => ({
-                                name: f.name,
-                                path: f.path,
-                                html_url: f.html_url,
-                                repository: { full_name: f.repository.full_name },
-                            })),
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerFileDelete(server) {
-    server.registerTool("file_delete", {
-        description: "Delete a file from a GitHub repository. Requires the SHA of the file (obtain from file_get_content).",
-        inputSchema: OwnerRepoSchema.extend({
-            path: z.string().min(1).describe("Path to the file to delete"),
-            message: z.string().min(1).describe("Commit message"),
-            branch: z.string().min(1).describe("Branch to delete the file from"),
-            sha: z.string().min(1).describe("SHA of the file to delete (obtain from file_get_content or file_create_update)"),
-        }),
-    }, async ({ owner, repo, path, message, branch, sha }) => {
-        try {
-            const pinErr = validatePinnedOwnerRepo(owner, repo);
-            if (pinErr)
-                return pinErr;
-            const octokit = createClient();
-            const response = await octokit.rest.repos.deleteFile({
-                owner, repo, path, message, branch, sha,
-            });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            commit: {
-                                sha: response.data.commit.sha,
-                                message: response.data.commit.message,
-                                html_url: response.data.commit.html_url,
-                            },
-                            content: null,
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}
-export function registerRepositorySearch(server) {
-    server.registerTool("repository_search", {
-        description: "Search for GitHub repositories by query. Supports GitHub search qualifiers like 'org:...', 'language:...', 'stars:>100'.",
-        inputSchema: z.object({
-            query: z.string().min(1).max(1000).describe("Search query with GitHub qualifiers, e.g., 'org:microsoft language:python'"),
-            page: PaginationSchema.shape.page,
-            per_page: PaginationSchema.shape.per_page,
-        }),
-    }, async ({ query, page, per_page }) => {
-        try {
-            const octokit = createClient();
-            const { data } = await octokit.rest.search.repos({ q: query, page, per_page });
-            return {
-                content: [{ type: "text", text: JSON.stringify({
-                            total_count: data.total_count,
-                            items: data.items.map((r) => ({
-                                ...formatRepo(r),
-                                html_url: r.html_url,
-                            })),
-                        }, null, 2) }],
-            };
-        }
-        catch (err) {
-            return handleGitHubError(err);
-        }
-    });
-}

package/dist/tools/server.d.ts

@@ -1,14 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export interface ServerMetadata {
-    name: string;
-    version: string;
-    description: string;
-    author: string;
-    license: string;
-    repository: string;
-    homepage: string;
-    bug_tracker: string;
-    bin: Record<string, string>;
-    tool_count: number;
-}
-export declare function registerServerInfo(server: McpServer, meta: ServerMetadata): void;

package/dist/tools/server.js

@@ -1,37 +0,0 @@
-import * as z from "zod/v4";
-export function registerServerInfo(server, meta) {
-    server.registerTool("server_info", {
-        description: "Get information about this MCP server, including version, support links, and runtime configuration.",
-        inputSchema: z.object({}),
-    }, async () => {
-        const runtime = {
-            node_version: process.version,
-            platform: process.platform,
-            pinned_owner: process.env.GITHUB_OWNER ?? null,
-            pinned_repo: process.env.GITHUB_REPO ?? null,
-            log_level: process.env.GITHUB_LOG_LEVEL ?? "error",
-            retry_max_attempts: parseInt(process.env.GITHUB_RETRY_MAX_ATTEMPTS ?? "3", 10),
-            circuit_breaker_threshold: parseInt(process.env.GITHUB_CIRCUIT_BREAKER_THRESHOLD ?? "5", 10),
-        };
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        name: meta.name,
-                        version: meta.version,
-                        description: meta.description,
-                        author: meta.author,
-                        license: meta.license,
-                        repository: meta.repository,
-                        homepage: meta.homepage,
-                        bug_tracker: meta.bug_tracker,
-                        npm_package: "https://www.npmjs.com/package/github-pro-mcp",
-                        docker_image: "https://hub.docker.com/r/anantanandgupta/github-pro-mcp",
-                        bin: meta.bin,
-                        tools_registered: meta.tool_count,
-                        runtime,
-                    }, null, 2),
-                }],
-        };
-    });
-}

package/dist/types/github-api.d.ts

@@ -1,63 +0,0 @@
-export interface IssueResponse {
-    number: number;
-    title: string;
-    body: string | null;
-    state: string;
-    html_url: string;
-    created_at: string;
-    updated_at: string;
-    closed_at: string | null;
-    user: {
-        login: string;
-        avatar_url: string;
-    } | null;
-    labels: Array<{
-        name?: string;
-        color?: string;
-    } | string>;
-    assignees?: Array<{
-        login: string;
-    }>;
-    milestone: {
-        title: string;
-        number: number;
-    } | null;
-    issue_field_values?: Array<{
-        issue_field_id: number;
-        node_id: string;
-        data_type: string;
-        value: string | number | null;
-        single_select_option?: {
-            id: number;
-            name: string;
-        };
-    }>;
-}
-export interface CreateOrUpdateFileResponse {
-    commit: {
-        sha: string;
-        message: string;
-        html_url: string;
-    };
-    content?: {
-        sha: string;
-    };
-}
-export interface UserResponse {
-    login: string;
-    name: string | null;
-    type: string;
-    avatar_url: string;
-    html_url: string;
-    description?: string | null;
-    bio?: string | null;
-}
-export interface SearchUserItem {
-    login: string;
-    description?: string | null;
-    html_url: string;
-}
-export interface LabelItem {
-    name?: string;
-    color?: string;
-}

package/dist/types/github-api.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/circuitBreaker.d.ts

@@ -1,11 +0,0 @@
-type CircuitState = "CLOSED" | "OPEN" | "HALF_OPEN";
-export declare class CircuitBreakerError extends Error {
-    constructor(breakerName: string);
-}
-export declare function withCircuitBreaker<T>(fn: () => Promise<T>, name: string): Promise<T>;
-export declare function getCircuitBreakerState(name: string): {
-    state: CircuitState;
-    failureCount: number;
-    lastFailureTime: number;
-} | null;
-export {};

package/dist/utils/circuitBreaker.js

@@ -1,125 +0,0 @@
-import { createLogger } from "./logger.js";
-const log = createLogger("circuit-breaker");
-const breakers = new Map();
-function defaultConfig() {
-    return {
-        failureThreshold: parseInt(process.env.GITHUB_CIRCUIT_BREAKER_THRESHOLD ?? "5", 10),
-        resetTimeoutMs: parseInt(process.env.GITHUB_CIRCUIT_BREAKER_RESET_MS ?? "30000", 10),
-        halfOpenMaxRequests: 1,
-    };
-}
-function getOrCreateBreaker(name) {
-    let breaker = breakers.get(name);
-    if (!breaker) {
-        breaker = {
-            state: "CLOSED",
-            failureCount: 0,
-            lastFailureTime: 0,
-            halfOpenRequestCount: 0,
-        };
-        breakers.set(name, breaker);
-    }
-    return breaker;
-}
-function transitionToOpen(breaker, name) {
-    if (breaker.state === "OPEN")
-        return;
-    breaker.state = "OPEN";
-    breaker.failureCount = 0;
-    breaker.halfOpenRequestCount = 0;
-    log.warn(`Circuit "${name}" OPEN — failing fast for ${defaultConfig().resetTimeoutMs / 1000}s`);
-}
-function transitionToHalfOpen(breaker, name) {
-    breaker.state = "HALF_OPEN";
-    breaker.halfOpenRequestCount = 0;
-    log.info(`Circuit "${name}" HALF_OPEN — testing service availability`);
-}
-function transitionToClosed(breaker, name) {
-    breaker.state = "CLOSED";
-    breaker.failureCount = 0;
-    breaker.halfOpenRequestCount = 0;
-    log.info(`Circuit "${name}" CLOSED — service recovered`);
-}
-function shouldAllowRequest(breaker, config) {
-    switch (breaker.state) {
-        case "CLOSED":
-            return true;
-        case "OPEN": {
-            const elapsed = Date.now() - breaker.lastFailureTime;
-            if (elapsed >= config.resetTimeoutMs) {
-                transitionToHalfOpen(breaker, "");
-                return true;
-            }
-            return false;
-        }
-        case "HALF_OPEN":
-            return breaker.halfOpenRequestCount < config.halfOpenMaxRequests;
-    }
-}
-function recordSuccess(breaker, name) {
-    if (breaker.state === "HALF_OPEN") {
-        transitionToClosed(breaker, name);
-    }
-    if (breaker.state === "CLOSED") {
-        breaker.failureCount = 0;
-    }
-}
-function recordFailure(breaker, config, name) {
-    breaker.lastFailureTime = Date.now();
-    switch (breaker.state) {
-        case "CLOSED":
-            breaker.failureCount++;
-            if (breaker.failureCount >= config.failureThreshold) {
-                transitionToOpen(breaker, name);
-            }
-            break;
-        case "HALF_OPEN":
-            transitionToOpen(breaker, name);
-            break;
-        case "OPEN":
-            break;
-    }
-}
-export class CircuitBreakerError extends Error {
-    constructor(breakerName) {
-        super(`Circuit breaker "${breakerName}" is OPEN. ` +
-            `GitHub API requests are temporarily blocked due to repeated failures. ` +
-            `The circuit will test the service automatically after the reset timeout.`);
-        this.name = "CircuitBreakerError";
-    }
-}
-export async function withCircuitBreaker(fn, name) {
-    const config = defaultConfig();
-    const breaker = getOrCreateBreaker(name);
-    if (!shouldAllowRequest(breaker, config)) {
-        throw new CircuitBreakerError(name);
-    }
-    if (breaker.state === "HALF_OPEN") {
-        breaker.halfOpenRequestCount++;
-    }
-    try {
-        const result = await fn();
-        recordSuccess(breaker, name);
-        return result;
-    }
-    catch (error) {
-        const status = error?.status;
-        const isServiceFailure = typeof status === "number" &&
-            (status >= 500 || status === 429);
-        const isNetworkError = error?.code && ["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND", "EPIPE"].includes(error.code);
-        if (isServiceFailure || isNetworkError) {
-            recordFailure(breaker, config, name);
-        }
-        throw error;
-    }
-}
-export function getCircuitBreakerState(name) {
-    const breaker = breakers.get(name);
-    if (!breaker)
-        return null;
-    return {
-        state: breaker.state,
-        failureCount: breaker.failureCount,
-        lastFailureTime: breaker.lastFailureTime,
-    };
-}

package/dist/utils/errors.d.ts

@@ -1,17 +0,0 @@
-interface ErrorResponse {
-    content: [{
-        type: "text";
-        text: string;
-    }];
-    isError: true;
-    [x: string]: unknown;
-}
-/**
- * Convert any GitHub API error (REST or GraphQL) into a structured
- * MCP error response with actionable guidance.
- *
- * Automatically increments the metrics counter for the error category.
- */
-export declare function handleGitHubError(err: unknown): ErrorResponse;
-export declare function formatZodErrors(err: unknown): string | null;
-export {};