@feedmob/github-issues 0.0.2

package/README.md

@@ -0,0 +1,125 @@
+# GitHub MCP Server
+
+MCP Server for the GitHub API, enabling issue operations and search functionality.
+
+## Features
+
+The GitHub MCP Server provides the following capabilities:
+- Create and manage GitHub issues
+- Search for issues across repositories
+- List and filter repository issues
+- Update existing issues
+- Get details of specific issues
+
+## Tools
+
+### `create_issue`
+- Create a new issue in a GitHub repository
+- Inputs:
+  - `owner` (string): Repository owner
+  - `repo` (string): Repository name
+  - `title` (string): Issue title
+  - `body` (optional string): Issue description
+  - `assignees` (optional string[]): Usernames to assign
+  - `labels` (optional string[]): Labels to add
+  - `milestone` (optional number): Milestone number
+- Returns: Created issue details
+
+### `list_issues`
+- List and filter repository issues
+- Inputs:
+  - `owner` (string): Repository owner
+  - `repo` (string): Repository name
+  - `state` (optional string): Filter by state ('open', 'closed', 'all')
+  - `labels` (optional string[]): Filter by labels
+  - `sort` (optional string): Sort by ('created', 'updated', 'comments')
+  - `direction` (optional string): Sort direction ('asc', 'desc')
+  - `since` (optional string): Filter by date (ISO 8601 timestamp)
+  - `page` (optional number): Page number
+  - `per_page` (optional number): Results per page
+- Returns: Array of issue details
+
+### `update_issue`
+- Update an existing issue
+- Inputs:
+  - `owner` (string): Repository owner
+  - `repo` (string): Repository name
+  - `issue_number` (number): Issue number to update
+  - `title` (optional string): New title
+  - `body` (optional string): New description
+  - `state` (optional string): New state ('open' or 'closed')
+  - `labels` (optional string[]): New labels
+  - `assignees` (optional string[]): New assignees
+  - `milestone` (optional number): New milestone number
+- Returns: Updated issue details
+
+### `search_issues`
+- Search for issues and pull requests across GitHub repositories
+- Inputs:
+  - `q` (string): Search query using GitHub issues search syntax
+  - `sort` (optional string): Sort field (comments, reactions, created, etc.)
+  - `order` (optional string): Sort order ('asc' or 'desc')
+  - `per_page` (optional number): Results per page (max 100)
+  - `page` (optional number): Page number
+- Returns: Issue and pull request search results
+
+### `get_issue`
+- Gets the contents of an issue within a repository
+- Inputs:
+  - `owner` (string): Repository owner
+  - `repo` (string): Repository name
+  - `issue_number` (number): Issue number to retrieve
+- Returns: GitHub Issue object & details
+
+## Search Query Syntax
+
+### Issues Search
+- `is:issue` or `is:pr`: Filter by type
+- `is:open` or `is:closed`: Filter by state
+- `label:bug`: Search by label
+- `author:username`: Search by author
+- Example: `q: "memory leak" is:issue is:open label:bug`
+
+For detailed search syntax, see [GitHub's searching documentation](https://docs.github.com/en/search-github/searching-on-github).
+
+## Setup
+
+### Environment Variables
+This server supports the following environment variables:
+- `GITHUB_PERSONAL_ACCESS_TOKEN`: Your GitHub Personal Access Token (required)
+- `GITHUB_DEFAULT_OWNER`: Default repository owner (optional)
+- `GITHUB_DEFAULT_REPO`: Default repository name (optional)
+
+### Personal Access Token
+[Create a GitHub Personal Access Token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens) with appropriate permissions:
+   - Go to [Personal access tokens](https://github.com/settings/tokens) (in GitHub Settings > Developer settings)
+   - Select which repositories you'd like this token to have access to (Public, All, or Select)
+   - Create a token with the `repo` scope ("Full control of private repositories")
+     - Alternatively, if working only with public repositories, select only the `public_repo` scope
+   - Copy the generated token
+
+### Usage with Claude Desktop
+To use this with Claude Desktop, add the following to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@feedmob/github-issues"
+      ],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>",
+        "GITHUB_DEFAULT_OWNER": "optional-default-owner",
+        "GITHUB_DEFAULT_REPO": "optional-default-repo"
+      }
+    }
+  }
+}
+```
+
+## License
+
+This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

package/dist/common/errors.js

@@ -0,0 +1,69 @@
+export class GitHubError extends Error {
+    status;
+    response;
+    constructor(message, status, response) {
+        super(message);
+        this.status = status;
+        this.response = response;
+        this.name = "GitHubError";
+    }
+}
+export class GitHubValidationError extends GitHubError {
+    constructor(message, status, response) {
+        super(message, status, response);
+        this.name = "GitHubValidationError";
+    }
+}
+export class GitHubResourceNotFoundError extends GitHubError {
+    constructor(resource) {
+        super(`Resource not found: ${resource}`, 404, { message: `${resource} not found` });
+        this.name = "GitHubResourceNotFoundError";
+    }
+}
+export class GitHubAuthenticationError extends GitHubError {
+    constructor(message = "Authentication failed") {
+        super(message, 401, { message });
+        this.name = "GitHubAuthenticationError";
+    }
+}
+export class GitHubPermissionError extends GitHubError {
+    constructor(message = "Insufficient permissions") {
+        super(message, 403, { message });
+        this.name = "GitHubPermissionError";
+    }
+}
+export class GitHubRateLimitError extends GitHubError {
+    resetAt;
+    constructor(message = "Rate limit exceeded", resetAt) {
+        super(message, 429, { message, reset_at: resetAt.toISOString() });
+        this.resetAt = resetAt;
+        this.name = "GitHubRateLimitError";
+    }
+}
+export class GitHubConflictError extends GitHubError {
+    constructor(message) {
+        super(message, 409, { message });
+        this.name = "GitHubConflictError";
+    }
+}
+export function isGitHubError(error) {
+    return error instanceof GitHubError;
+}
+export function createGitHubError(status, response) {
+    switch (status) {
+        case 401:
+            return new GitHubAuthenticationError(response?.message);
+        case 403:
+            return new GitHubPermissionError(response?.message);
+        case 404:
+            return new GitHubResourceNotFoundError(response?.message || "Resource");
+        case 409:
+            return new GitHubConflictError(response?.message || "Conflict occurred");
+        case 422:
+            return new GitHubValidationError(response?.message || "Validation failed", status, response);
+        case 429:
+            return new GitHubRateLimitError(response?.message, new Date(response?.reset_at || Date.now() + 60000));
+        default:
+            return new GitHubError(response?.message || "GitHub API error", status, response);
+    }
+}

package/dist/common/types.js

@@ -0,0 +1,220 @@
+import { z } from "zod";
+// Base schemas for common types
+export const GitHubAuthorSchema = z.object({
+    name: z.string(),
+    email: z.string(),
+    date: z.string(),
+});
+export const GitHubOwnerSchema = z.object({
+    login: z.string(),
+    id: z.number(),
+    node_id: z.string(),
+    avatar_url: z.string(),
+    url: z.string(),
+    html_url: z.string(),
+    type: z.string(),
+});
+export const GitHubRepositorySchema = z.object({
+    id: z.number(),
+    node_id: z.string(),
+    name: z.string(),
+    full_name: z.string(),
+    private: z.boolean(),
+    owner: GitHubOwnerSchema,
+    html_url: z.string(),
+    description: z.string().nullable(),
+    fork: z.boolean(),
+    url: z.string(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    pushed_at: z.string(),
+    git_url: z.string(),
+    ssh_url: z.string(),
+    clone_url: z.string(),
+    default_branch: z.string(),
+});
+export const GithubFileContentLinks = z.object({
+    self: z.string(),
+    git: z.string().nullable(),
+    html: z.string().nullable()
+});
+export const GitHubFileContentSchema = z.object({
+    name: z.string(),
+    path: z.string(),
+    sha: z.string(),
+    size: z.number(),
+    url: z.string(),
+    html_url: z.string(),
+    git_url: z.string(),
+    download_url: z.string(),
+    type: z.string(),
+    content: z.string().optional(),
+    encoding: z.string().optional(),
+    _links: GithubFileContentLinks
+});
+export const GitHubDirectoryContentSchema = z.object({
+    type: z.string(),
+    size: z.number(),
+    name: z.string(),
+    path: z.string(),
+    sha: z.string(),
+    url: z.string(),
+    git_url: z.string(),
+    html_url: z.string(),
+    download_url: z.string().nullable(),
+});
+export const GitHubContentSchema = z.union([
+    GitHubFileContentSchema,
+    z.array(GitHubDirectoryContentSchema),
+]);
+export const GitHubTreeEntrySchema = z.object({
+    path: z.string(),
+    mode: z.enum(["100644", "100755", "040000", "160000", "120000"]),
+    type: z.enum(["blob", "tree", "commit"]),
+    size: z.number().optional(),
+    sha: z.string(),
+    url: z.string(),
+});
+export const GitHubTreeSchema = z.object({
+    sha: z.string(),
+    url: z.string(),
+    tree: z.array(GitHubTreeEntrySchema),
+    truncated: z.boolean(),
+});
+export const GitHubCommitSchema = z.object({
+    sha: z.string(),
+    node_id: z.string(),
+    url: z.string(),
+    author: GitHubAuthorSchema,
+    committer: GitHubAuthorSchema,
+    message: z.string(),
+    tree: z.object({
+        sha: z.string(),
+        url: z.string(),
+    }),
+    parents: z.array(z.object({
+        sha: z.string(),
+        url: z.string(),
+    })),
+});
+export const GitHubListCommitsSchema = z.array(z.object({
+    sha: z.string(),
+    node_id: z.string(),
+    commit: z.object({
+        author: GitHubAuthorSchema,
+        committer: GitHubAuthorSchema,
+        message: z.string(),
+        tree: z.object({
+            sha: z.string(),
+            url: z.string()
+        }),
+        url: z.string(),
+        comment_count: z.number(),
+    }),
+    url: z.string(),
+    html_url: z.string(),
+    comments_url: z.string()
+}));
+export const GitHubReferenceSchema = z.object({
+    ref: z.string(),
+    node_id: z.string(),
+    url: z.string(),
+    object: z.object({
+        sha: z.string(),
+        type: z.string(),
+        url: z.string(),
+    }),
+});
+// User and assignee schemas
+export const GitHubIssueAssigneeSchema = z.object({
+    login: z.string(),
+    id: z.number(),
+    avatar_url: z.string(),
+    url: z.string(),
+    html_url: z.string(),
+});
+// Issue-related schemas
+export const GitHubLabelSchema = z.object({
+    id: z.number(),
+    node_id: z.string(),
+    url: z.string(),
+    name: z.string(),
+    color: z.string(),
+    default: z.boolean(),
+    description: z.string().nullable().optional(),
+});
+export const GitHubMilestoneSchema = z.object({
+    url: z.string(),
+    html_url: z.string(),
+    labels_url: z.string(),
+    id: z.number(),
+    node_id: z.string(),
+    number: z.number(),
+    title: z.string(),
+    description: z.string(),
+    state: z.string(),
+});
+export const GitHubIssueSchema = z.object({
+    url: z.string(),
+    repository_url: z.string(),
+    labels_url: z.string(),
+    comments_url: z.string(),
+    events_url: z.string(),
+    html_url: z.string(),
+    id: z.number(),
+    node_id: z.string(),
+    number: z.number(),
+    title: z.string(),
+    user: GitHubIssueAssigneeSchema,
+    labels: z.array(GitHubLabelSchema),
+    state: z.string(),
+    locked: z.boolean(),
+    assignee: GitHubIssueAssigneeSchema.nullable(),
+    assignees: z.array(GitHubIssueAssigneeSchema),
+    milestone: GitHubMilestoneSchema.nullable(),
+    comments: z.number(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    closed_at: z.string().nullable(),
+    body: z.string().nullable(),
+});
+// Search-related schemas
+export const GitHubSearchResponseSchema = z.object({
+    total_count: z.number(),
+    incomplete_results: z.boolean(),
+    items: z.array(GitHubRepositorySchema),
+});
+// Pull request schemas
+export const GitHubPullRequestRefSchema = z.object({
+    label: z.string(),
+    ref: z.string(),
+    sha: z.string(),
+    user: GitHubIssueAssigneeSchema,
+    repo: GitHubRepositorySchema,
+});
+export const GitHubPullRequestSchema = z.object({
+    url: z.string(),
+    id: z.number(),
+    node_id: z.string(),
+    html_url: z.string(),
+    diff_url: z.string(),
+    patch_url: z.string(),
+    issue_url: z.string(),
+    number: z.number(),
+    state: z.string(),
+    locked: z.boolean(),
+    title: z.string(),
+    user: GitHubIssueAssigneeSchema,
+    body: z.string().nullable(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    closed_at: z.string().nullable(),
+    merged_at: z.string().nullable(),
+    merge_commit_sha: z.string().nullable(),
+    assignee: GitHubIssueAssigneeSchema.nullable(),
+    assignees: z.array(GitHubIssueAssigneeSchema),
+    requested_reviewers: z.array(GitHubIssueAssigneeSchema),
+    labels: z.array(GitHubLabelSchema),
+    head: GitHubPullRequestRefSchema,
+    base: GitHubPullRequestRefSchema,
+});

package/dist/common/utils.js

@@ -0,0 +1,107 @@
+import { getUserAgent } from "universal-user-agent";
+import { createGitHubError } from "./errors.js";
+import { VERSION } from "./version.js";
+async function parseResponseBody(response) {
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+        return response.json();
+    }
+    return response.text();
+}
+export function buildUrl(baseUrl, params) {
+    const url = new URL(baseUrl);
+    Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.append(key, value.toString());
+        }
+    });
+    return url.toString();
+}
+const USER_AGENT = `modelcontextprotocol/servers/github/v${VERSION} ${getUserAgent()}`;
+export async function githubRequest(url, options = {}) {
+    const headers = {
+        "Accept": "application/vnd.github.v3+json",
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+        ...options.headers,
+    };
+    if (process.env.GITHUB_PERSONAL_ACCESS_TOKEN) {
+        headers["Authorization"] = `Bearer ${process.env.GITHUB_PERSONAL_ACCESS_TOKEN}`;
+    }
+    const response = await fetch(url, {
+        method: options.method || "GET",
+        headers,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+    const responseBody = await parseResponseBody(response);
+    if (!response.ok) {
+        throw createGitHubError(response.status, responseBody);
+    }
+    return responseBody;
+}
+export function validateBranchName(branch) {
+    const sanitized = branch.trim();
+    if (!sanitized) {
+        throw new Error("Branch name cannot be empty");
+    }
+    if (sanitized.includes("..")) {
+        throw new Error("Branch name cannot contain '..'");
+    }
+    if (/[\s~^:?*[\\\]]/.test(sanitized)) {
+        throw new Error("Branch name contains invalid characters");
+    }
+    if (sanitized.startsWith("/") || sanitized.endsWith("/")) {
+        throw new Error("Branch name cannot start or end with '/'");
+    }
+    if (sanitized.endsWith(".lock")) {
+        throw new Error("Branch name cannot end with '.lock'");
+    }
+    return sanitized;
+}
+export function validateRepositoryName(name) {
+    const sanitized = name.trim().toLowerCase();
+    if (!sanitized) {
+        throw new Error("Repository name cannot be empty");
+    }
+    if (!/^[a-z0-9_.-]+$/.test(sanitized)) {
+        throw new Error("Repository name can only contain lowercase letters, numbers, hyphens, periods, and underscores");
+    }
+    if (sanitized.startsWith(".") || sanitized.endsWith(".")) {
+        throw new Error("Repository name cannot start or end with a period");
+    }
+    return sanitized;
+}
+export function validateOwnerName(owner) {
+    const sanitized = owner.trim().toLowerCase();
+    if (!sanitized) {
+        throw new Error("Owner name cannot be empty");
+    }
+    if (!/^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9])){0,38}$/.test(sanitized)) {
+        throw new Error("Owner name must start with a letter or number and can contain up to 39 characters");
+    }
+    return sanitized;
+}
+export async function checkBranchExists(owner, repo, branch) {
+    try {
+        await githubRequest(`https://api.github.com/repos/${owner}/${repo}/branches/${branch}`);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "status" in error && error.status === 404) {
+            return false;
+        }
+        throw error;
+    }
+}
+export async function checkUserExists(username) {
+    try {
+        await githubRequest(`https://api.github.com/users/${username}`);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "status" in error && error.status === 404) {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/common/version.js

@@ -0,0 +1,3 @@
+// If the format of this file changes, so it doesn't simply export a VERSION constant,
+// this will break .github/workflows/version-check.yml.
+export const VERSION = "0.0.2";

package/dist/index.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import fetch from 'node-fetch';
+import * as issues from './operations/issues.js';
+import * as search from './operations/search.js';
+import { GitHubValidationError, GitHubResourceNotFoundError, GitHubAuthenticationError, GitHubPermissionError, GitHubRateLimitError, GitHubConflictError, isGitHubError, } from './common/errors.js';
+import { VERSION } from "./common/version.js";
+// If fetch doesn't exist in global scope, add it
+if (!globalThis.fetch) {
+    globalThis.fetch = fetch;
+}
+// Default values from environment variables
+const DEFAULT_OWNER = process.env.GITHUB_DEFAULT_OWNER || '';
+const DEFAULT_REPO = process.env.GITHUB_DEFAULT_REPO || '';
+const server = new Server({
+    name: "github-mcp-server",
+    version: VERSION,
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+function formatGitHubError(error) {
+    let message = `GitHub API Error: ${error.message}`;
+    if (error instanceof GitHubValidationError) {
+        message = `Validation Error: ${error.message}`;
+        if (error.response) {
+            message += `\nDetails: ${JSON.stringify(error.response)}`;
+        }
+    }
+    else if (error instanceof GitHubResourceNotFoundError) {
+        message = `Not Found: ${error.message}`;
+    }
+    else if (error instanceof GitHubAuthenticationError) {
+        message = `Authentication Failed: ${error.message}`;
+    }
+    else if (error instanceof GitHubPermissionError) {
+        message = `Permission Denied: ${error.message}`;
+    }
+    else if (error instanceof GitHubRateLimitError) {
+        message = `Rate Limit Exceeded: ${error.message}\nResets at: ${error.resetAt.toISOString()}`;
+    }
+    else if (error instanceof GitHubConflictError) {
+        message = `Conflict: ${error.message}`;
+    }
+    return message;
+}
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "create_issue",
+                description: "Create a new issue in a GitHub repository",
+                inputSchema: zodToJsonSchema(issues.CreateIssueSchema),
+            },
+            {
+                name: "list_issues",
+                description: "List issues in a GitHub repository with filtering options",
+                inputSchema: zodToJsonSchema(issues.ListIssuesOptionsSchema)
+            },
+            {
+                name: "update_issue",
+                description: "Update an existing issue in a GitHub repository",
+                inputSchema: zodToJsonSchema(issues.UpdateIssueOptionsSchema)
+            },
+            {
+                name: "search_issues",
+                description: "Search for issues and pull requests across GitHub repositories",
+                inputSchema: zodToJsonSchema(search.SearchIssuesSchema),
+            },
+            {
+                name: "get_issue",
+                description: "Get details of a specific issue in a GitHub repository.",
+                inputSchema: zodToJsonSchema(issues.GetIssueSchema)
+            }
+        ],
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        if (!request.params.arguments) {
+            throw new Error("Arguments are required");
+        }
+        switch (request.params.name) {
+            case "create_issue": {
+                const args = issues.CreateIssueSchema.parse(request.params.arguments);
+                // Use default values from environment variables if not provided
+                const owner = args.owner || DEFAULT_OWNER;
+                const repo = args.repo || DEFAULT_REPO;
+                const { ...options } = args;
+                if (!owner || !repo) {
+                    throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER and GITHUB_DEFAULT_REPO environment variables.");
+                }
+                try {
+                    console.error(`[DEBUG] Attempting to create issue in ${owner}/${repo}`);
+                    console.error(`[DEBUG] Issue options:`, JSON.stringify(options, null, 2));
+                    const issue = await issues.createIssue(owner, repo, options);
+                    console.error(`[DEBUG] Issue created successfully`);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
+                    };
+                }
+                catch (err) {
+                    // Type guard for Error objects
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    console.error(`[ERROR] Failed to create issue:`, error);
+                    if (error instanceof GitHubResourceNotFoundError) {
+                        throw new Error(`Repository '${owner}/${repo}' not found. Please verify:\n` +
+                            `1. The repository exists\n` +
+                            `2. You have correct access permissions\n` +
+                            `3. The owner and repository names are spelled correctly`);
+                    }
+                    // Safely access error properties
+                    throw new Error(`Failed to create issue: ${error.message}${error.stack ? `\nStack: ${error.stack}` : ''}`);
+                }
+            }
+            case "search_issues": {
+                const args = search.SearchIssuesSchema.parse(request.params.arguments);
+                const results = await search.searchIssues(args);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+                };
+            }
+            case "list_issues": {
+                const args = issues.ListIssuesOptionsSchema.parse(request.params.arguments);
+                // Use default values from environment variables if not provided
+                const owner = args.owner || DEFAULT_OWNER;
+                const repo = args.repo || DEFAULT_REPO;
+                const { ...options } = args;
+                if (!owner || !repo) {
+                    throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER and GITHUB_DEFAULT_REPO environment variables.");
+                }
+                const result = await issues.listIssues(owner, repo, options);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "update_issue": {
+                const args = issues.UpdateIssueOptionsSchema.parse(request.params.arguments);
+                // Use default values from environment variables if not provided
+                const owner = args.owner || DEFAULT_OWNER;
+                const repo = args.repo || DEFAULT_REPO;
+                const { issue_number, ...options } = args;
+                if (!owner || !repo) {
+                    throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER and GITHUB_DEFAULT_REPO environment variables.");
+                }
+                const result = await issues.updateIssue(owner, repo, issue_number, options);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            case "get_issue": {
+                const args = issues.GetIssueSchema.parse(request.params.arguments);
+                // Use default values from environment variables if not provided
+                const owner = args.owner || DEFAULT_OWNER;
+                const repo = args.repo || DEFAULT_REPO;
+                const { issue_number } = args;
+                if (!owner || !repo) {
+                    throw new Error("Repository owner and name are required. Either provide them directly or set GITHUB_DEFAULT_OWNER and GITHUB_DEFAULT_REPO environment variables.");
+                }
+                const issue = await issues.getIssue(owner, repo, issue_number);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(issue, null, 2) }],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${request.params.name}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new Error(`Invalid input: ${JSON.stringify(error.errors)}`);
+        }
+        if (isGitHubError(error)) {
+            throw new Error(formatGitHubError(error));
+        }
+        throw error;
+    }
+});
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("GitHub MCP Server running on stdio");
+    if (DEFAULT_OWNER && DEFAULT_REPO) {
+        console.error(`Using default repository: ${DEFAULT_OWNER}/${DEFAULT_REPO}`);
+    }
+}
+runServer().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/operations/issues.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { githubRequest, buildUrl } from "../common/utils.js";
+export const GetIssueSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    issue_number: z.number(),
+});
+export const IssueCommentSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    issue_number: z.number(),
+    body: z.string(),
+});
+export const CreateIssueOptionsSchema = z.object({
+    title: z.string(),
+    body: z.string().optional(),
+    assignees: z.array(z.string()).optional(),
+    milestone: z.number().optional(),
+    labels: z.array(z.string()).optional(),
+});
+export const CreateIssueSchema = z.object({
+    owner: z.string().optional(),
+    repo: z.string().optional(),
+    ...CreateIssueOptionsSchema.shape,
+});
+export const ListIssuesOptionsSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    direction: z.enum(["asc", "desc"]).optional(),
+    labels: z.array(z.string()).optional(),
+    page: z.number().optional(),
+    per_page: z.number().optional(),
+    since: z.string().optional(),
+    sort: z.enum(["created", "updated", "comments"]).optional(),
+    state: z.enum(["open", "closed", "all"]).optional(),
+});
+export const UpdateIssueOptionsSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    issue_number: z.number(),
+    title: z.string().optional(),
+    body: z.string().optional(),
+    assignees: z.array(z.string()).optional(),
+    milestone: z.number().optional(),
+    labels: z.array(z.string()).optional(),
+    state: z.enum(["open", "closed"]).optional(),
+});
+export async function getIssue(owner, repo, issue_number) {
+    return githubRequest(`https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}`);
+}
+export async function addIssueComment(owner, repo, issue_number, body) {
+    return githubRequest(`https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}/comments`, {
+        method: "POST",
+        body: { body },
+    });
+}
+export async function createIssue(owner, repo, options) {
+    return githubRequest(`https://api.github.com/repos/${owner}/${repo}/issues`, {
+        method: "POST",
+        body: options,
+    });
+}
+export async function listIssues(owner, repo, options) {
+    const urlParams = {
+        direction: options.direction,
+        labels: options.labels?.join(","),
+        page: options.page?.toString(),
+        per_page: options.per_page?.toString(),
+        since: options.since,
+        sort: options.sort,
+        state: options.state
+    };
+    return githubRequest(buildUrl(`https://api.github.com/repos/${owner}/${repo}/issues`, urlParams));
+}
+export async function updateIssue(owner, repo, issue_number, options) {
+    return githubRequest(`https://api.github.com/repos/${owner}/${repo}/issues/${issue_number}`, {
+        method: "PATCH",
+        body: options,
+    });
+}

package/dist/operations/search.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { githubRequest, buildUrl } from "../common/utils.js";
+export const SearchOptions = z.object({
+    q: z.string(),
+    order: z.enum(["asc", "desc"]).optional(),
+    page: z.number().min(1).optional(),
+    per_page: z.number().min(1).max(100).optional(),
+});
+export const SearchUsersOptions = SearchOptions.extend({
+    sort: z.enum(["followers", "repositories", "joined"]).optional(),
+});
+export const SearchIssuesOptions = SearchOptions.extend({
+    sort: z.enum([
+        "comments",
+        "reactions",
+        "reactions-+1",
+        "reactions--1",
+        "reactions-smile",
+        "reactions-thinking_face",
+        "reactions-heart",
+        "reactions-tada",
+        "interactions",
+        "created",
+        "updated",
+    ]).optional(),
+});
+export const SearchCodeSchema = SearchOptions;
+export const SearchUsersSchema = SearchUsersOptions;
+export const SearchIssuesSchema = SearchIssuesOptions;
+export async function searchCode(params) {
+    return githubRequest(buildUrl("https://api.github.com/search/code", params));
+}
+export async function searchIssues(params) {
+    return githubRequest(buildUrl("https://api.github.com/search/issues", params));
+}
+export async function searchUsers(params) {
+    return githubRequest(buildUrl("https://api.github.com/search/users", params));
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@feedmob/github-issues",
+  "version": "0.0.2",
+  "description": "MCP server for using the GitHub API",
+  "license": "MIT",
+  "author": "FeedMob",
+  "homepage": "https://github.com/feedmob/fm-mcp-servers",
+  "bugs": "https://github.com/feedmob/fm-mcp-servers/issues",
+  "type": "module",
+  "bin": {
+    "mcp-server-github": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.0.1",
+    "@types/node": "^22",
+    "@types/node-fetch": "^2.6.12",
+    "node-fetch": "^3.3.2",
+    "universal-user-agent": "^7.0.2",
+    "zod": "^3.22.4",
+    "zod-to-json-schema": "^3.23.5"
+  },
+  "devDependencies": {
+    "shx": "^0.3.4",
+    "typescript": "^5.6.2"
+  }
+}