issue-scribe-mcp 1.0.0 → 1.1.0

package/src/index.ts

@@ -11,6 +11,18 @@ import { z } from "zod";
 
 const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
 
+// Reaction type mapping: user-friendly names to GitHub API format
+const REACTION_MAP: Record<string, string> = {
+    "thumbs_up": "+1",
+    "thumbs_down": "-1",
+    "laugh": "laugh",
+    "confused": "confused",
+    "heart": "heart",
+    "hooray": "hooray",
+    "rocket": "rocket",
+    "eyes": "eyes",
+};
+
 if (!GITHUB_TOKEN) {
     console.error("Error: GITHUB_TOKEN environment variable is required");
     process.exit(1);
@@ -61,6 +73,86 @@ const CreatePRSchema = z.object({
     maintainer_can_modify: z.boolean().optional(),
 });
 
+const AddCommentSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    issue_number: z.number(), // works for both issues and PRs
+    body: z.string(),
+});
+
+const UpdateCommentSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    comment_id: z.number(),
+    body: z.string(),
+});
+
+const DeleteCommentSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    comment_id: z.number(),
+});
+
+const AddReactionSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    comment_id: z.number().optional(),
+    issue_number: z.number().optional(),
+    reaction: z.enum(["thumbs_up", "thumbs_down", "laugh", "confused", "heart", "hooray", "rocket", "eyes"]),
+}).refine(data => data.comment_id || data.issue_number, {
+    message: "Either comment_id or issue_number must be provided",
+});
+
+const SearchIssuesSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    query: z.string().optional(),
+    state: z.enum(["open", "closed", "all"]).optional(),
+    labels: z.array(z.string()).optional(),
+    sort: z.enum(["created", "updated", "comments"]).optional(),
+    direction: z.enum(["asc", "desc"]).optional(),
+    per_page: z.number().max(100).optional(),
+});
+
+const SearchPRsSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    query: z.string().optional(),
+    state: z.enum(["open", "closed", "all"]).optional(),
+    sort: z.enum(["created", "updated", "popularity", "long-running"]).optional(),
+    direction: z.enum(["asc", "desc"]).optional(),
+    per_page: z.number().max(100).optional(),
+});
+
+const ListRecentIssuesSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    state: z.enum(["open", "closed", "all"]).optional(),
+    sort: z.enum(["created", "updated"]).optional(),
+    per_page: z.number().max(100).optional(),
+});
+
+const MergePRSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    pull_number: z.number(),
+    merge_method: z.enum(["merge", "squash", "rebase"]).optional(),
+    commit_title: z.string().optional(),
+    commit_message: z.string().optional(),
+});
+
+const GetPRDiffSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    pull_number: z.number(),
+});
+
+const GetPRFilesSchema = z.object({
+    owner: z.string(),
+    repo: z.string(),
+    pull_number: z.number(),
+});
+
 const server = new Server(
     {
         name: "issue-scribe-mcp",
@@ -154,6 +246,158 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["owner", "repo", "title", "head", "base"],
                 },
             },
+            {
+                name: "github_add_comment",
+                description: "Add a comment to a GitHub Issue or Pull Request",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        issue_number: { type: "number", description: "Issue or PR number" },
+                        body: { type: "string", description: "Comment body text" },
+                    },
+                    required: ["owner", "repo", "issue_number", "body"],
+                },
+            },
+            {
+                name: "github_update_comment",
+                description: "Update an existing comment on a GitHub Issue or Pull Request",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        comment_id: { type: "number", description: "Comment ID to update" },
+                        body: { type: "string", description: "New comment body text" },
+                    },
+                    required: ["owner", "repo", "comment_id", "body"],
+                },
+            },
+            {
+                name: "github_delete_comment",
+                description: "Delete a comment from a GitHub Issue or Pull Request",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        comment_id: { type: "number", description: "Comment ID to delete" },
+                    },
+                    required: ["owner", "repo", "comment_id"],
+                },
+            },
+            {
+                name: "github_add_reaction",
+                description: "Add a reaction (emoji) to a comment or an issue/PR directly. Provide either comment_id OR issue_number.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        comment_id: { type: "number", description: "Comment ID to react to (optional if issue_number is provided)" },
+                        issue_number: { type: "number", description: "Issue/PR number to react to (optional if comment_id is provided)" },
+                        reaction: {
+                            type: "string",
+                            enum: ["thumbs_up", "thumbs_down", "laugh", "confused", "heart", "hooray", "rocket", "eyes"],
+                            description: "Reaction type: thumbs_up 👍, thumbs_down 👎, laugh 😄, confused 😕, heart ❤️, hooray 🎉, rocket 🚀, eyes 👀"
+                        },
+                    },
+                    required: ["owner", "repo", "reaction"],
+                },
+            },
+            {
+                name: "github_search_issues",
+                description: "Search for issues in a repository with advanced filters",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        query: { type: "string", description: "Search query (optional)" },
+                        state: { type: "string", enum: ["open", "closed", "all"], description: "Issue state (optional)" },
+                        labels: { type: "array", items: { type: "string" }, description: "Filter by labels (optional)" },
+                        sort: { type: "string", enum: ["created", "updated", "comments"], description: "Sort by (optional)" },
+                        direction: { type: "string", enum: ["asc", "desc"], description: "Sort direction (optional)" },
+                        per_page: { type: "number", description: "Results per page, max 100 (optional)" },
+                    },
+                    required: ["owner", "repo"],
+                },
+            },
+            {
+                name: "github_search_prs",
+                description: "Search for pull requests in a repository with advanced filters",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        query: { type: "string", description: "Search query (optional)" },
+                        state: { type: "string", enum: ["open", "closed", "all"], description: "PR state (optional)" },
+                        sort: { type: "string", enum: ["created", "updated", "popularity", "long-running"], description: "Sort by (optional)" },
+                        direction: { type: "string", enum: ["asc", "desc"], description: "Sort direction (optional)" },
+                        per_page: { type: "number", description: "Results per page, max 100 (optional)" },
+                    },
+                    required: ["owner", "repo"],
+                },
+            },
+            {
+                name: "github_list_recent_issues",
+                description: "List recent issues in a repository",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        state: { type: "string", enum: ["open", "closed", "all"], description: "Issue state (optional, default: open)" },
+                        sort: { type: "string", enum: ["created", "updated"], description: "Sort by (optional, default: created)" },
+                        per_page: { type: "number", description: "Results per page, max 100 (optional, default: 30)" },
+                    },
+                    required: ["owner", "repo"],
+                },
+            },
+            {
+                name: "github_merge_pr",
+                description: "Merge a pull request",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        pull_number: { type: "number", description: "PR number to merge" },
+                        merge_method: { type: "string", enum: ["merge", "squash", "rebase"], description: "Merge method (optional, default: merge)" },
+                        commit_title: { type: "string", description: "Custom commit title (optional)" },
+                        commit_message: { type: "string", description: "Custom commit message (optional)" },
+                    },
+                    required: ["owner", "repo", "pull_number"],
+                },
+            },
+            {
+                name: "github_get_pr_diff",
+                description: "Get the full diff of a pull request",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        pull_number: { type: "number", description: "PR number" },
+                    },
+                    required: ["owner", "repo", "pull_number"],
+                },
+            },
+            {
+                name: "github_get_pr_files",
+                description: "Get list of files changed in a pull request with details",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string", description: "Repository owner" },
+                        repo: { type: "string", description: "Repository name" },
+                        pull_number: { type: "number", description: "PR number" },
+                    },
+                    required: ["owner", "repo", "pull_number"],
+                },
+            },
         ],
     };
 });
@@ -189,9 +433,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                     ),
                                 },
                                 comments: comments.data.map((c) => ({
+                                    id: c.id,
                                     user: c.user?.login,
                                     body: c.body,
                                     created_at: c.created_at,
+                                    html_url: c.html_url,
                                 })),
                             },
                             null,
@@ -252,9 +498,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                     ),
                                 },
                                 comments: comments.data.map((c) => ({
+                                    id: c.id,
                                     user: c.user?.login,
                                     body: c.body,
                                     created_at: c.created_at,
+                                    html_url: c.html_url,
                                 })),
                                 commits: commits.data.map((c) => ({
                                     sha: c.sha,
@@ -461,6 +709,575 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
     }
 
+    if (name === "github_add_comment") {
+        try {
+            const { owner, repo, issue_number, body } = AddCommentSchema.parse(args);
+
+            const comment = await octokit.rest.issues.createComment({
+                owner,
+                repo,
+                issue_number,
+                body,
+            });
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                success: true,
+                                comment: {
+                                    id: comment.data.id,
+                                    body: comment.data.body,
+                                    user: comment.data.user?.login,
+                                    html_url: comment.data.html_url,
+                                    created_at: comment.data.created_at,
+                                },
+                                message: `Comment added successfully to issue/PR #${issue_number}`,
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const issueNum = args && typeof args === 'object' && 'issue_number' in args ? args.issue_number : 'unknown';
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to add comment to issue/PR #${issueNum} in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_update_comment") {
+        try {
+            const { owner, repo, comment_id, body } = UpdateCommentSchema.parse(args);
+
+            const comment = await octokit.rest.issues.updateComment({
+                owner,
+                repo,
+                comment_id,
+                body,
+            });
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                success: true,
+                                comment: {
+                                    id: comment.data.id,
+                                    body: comment.data.body,
+                                    user: comment.data.user?.login,
+                                    html_url: comment.data.html_url,
+                                    updated_at: comment.data.updated_at,
+                                },
+                                message: `Comment #${comment_id} updated successfully`,
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const commentId = args && typeof args === 'object' && 'comment_id' in args ? args.comment_id : 'unknown';
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to update comment #${commentId} in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_delete_comment") {
+        try {
+            const { owner, repo, comment_id } = DeleteCommentSchema.parse(args);
+
+            await octokit.rest.issues.deleteComment({
+                owner,
+                repo,
+                comment_id,
+            });
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                success: true,
+                                message: `Comment #${comment_id} deleted successfully`,
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const commentId = args && typeof args === 'object' && 'comment_id' in args ? args.comment_id : 'unknown';
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to delete comment #${commentId} in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_add_reaction") {
+        try {
+            const { owner, repo, comment_id, issue_number, reaction } = AddReactionSchema.parse(args);
+
+            let reactionResponse;
+            let target = "";
+
+            const githubReaction = REACTION_MAP[reaction] || reaction;
+
+            if (comment_id) {
+                // Add reaction to a comment
+                reactionResponse = await octokit.rest.reactions.createForIssueComment({
+                    owner,
+                    repo,
+                    comment_id,
+                    content: githubReaction as any,
+                });
+                target = `comment #${comment_id}`;
+            } else if (issue_number) {
+                // Add reaction to an issue/PR
+                reactionResponse = await octokit.rest.reactions.createForIssue({
+                    owner,
+                    repo,
+                    issue_number,
+                    content: githubReaction as any,
+                });
+                target = `issue/PR #${issue_number}`;
+            }
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                success: true,
+                                reaction: {
+                                    id: reactionResponse!.data.id,
+                                    content: reactionResponse!.data.content,
+                                    user: reactionResponse!.data.user?.login,
+                                    created_at: reactionResponse!.data.created_at,
+                                },
+                                message: `Reaction "${reaction}" added successfully to ${target}`,
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const commentId = args && typeof args === 'object' && 'comment_id' in args ? args.comment_id : undefined;
+            const issueNum = args && typeof args === 'object' && 'issue_number' in args ? args.issue_number : undefined;
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            const reaction = args && typeof args === 'object' && 'reaction' in args ? args.reaction : 'unknown';
+            const target = commentId ? `comment #${commentId}` : issueNum ? `issue/PR #${issueNum}` : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to add reaction "${reaction}" to ${target} in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_search_issues") {
+        try {
+            const { owner, repo, query, state, labels, sort, direction, per_page } = SearchIssuesSchema.parse(args);
+
+            const issues = await octokit.rest.issues.listForRepo({
+                owner,
+                repo,
+                state: state || "open",
+                labels: labels?.join(","),
+                sort: sort as any,
+                direction: direction as any,
+                per_page: per_page || 30,
+            });
+
+            // Filter out pull requests first
+            const issuesOnly = issues.data.filter(issue => !issue.pull_request);
+            const filteredIssues = query
+                ? issues.data.filter(issue => !issue.pull_request).filter(issue =>
+                    issue.title.toLowerCase().includes(query.toLowerCase()) ||
+                    issue.body?.toLowerCase().includes(query.toLowerCase())
+                )
+                : issues.data.filter(issue => !issue.pull_request);
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                total_count: filteredIssues.length,
+                                issues: filteredIssues.map(issue => ({
+                                    number: issue.number,
+                                    title: issue.title,
+                                    state: issue.state,
+                                    user: issue.user?.login,
+                                    labels: issue.labels.map((l: any) => typeof l === "string" ? l : l.name),
+                                    created_at: issue.created_at,
+                                    updated_at: issue.updated_at,
+                                    comments: issue.comments,
+                                    html_url: issue.html_url,
+                                })),
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to search issues in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_search_prs") {
+        try {
+            const { owner, repo, query, state, sort, direction, per_page } = SearchPRsSchema.parse(args);
+
+            const prs = await octokit.rest.pulls.list({
+                owner,
+                repo,
+                state: state || "open",
+                sort: sort as any,
+                direction: direction as any,
+                per_page: per_page || 30,
+            });
+
+            const filteredPRs = query
+                ? prs.data.filter(pr =>
+                    pr.title.toLowerCase().includes(query.toLowerCase()) ||
+                    pr.body?.toLowerCase().includes(query.toLowerCase())
+                )
+                : prs.data;
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                total_count: filteredPRs.length,
+                                pull_requests: filteredPRs.map(pr => ({
+                                    number: pr.number,
+                                    title: pr.title,
+                                    state: pr.state,
+                                    user: pr.user?.login,
+                                    head: pr.head.ref,
+                                    base: pr.base.ref,
+                                    created_at: pr.created_at,
+                                    updated_at: pr.updated_at,
+                                    draft: pr.draft,
+                                    html_url: pr.html_url,
+                                })),
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to search PRs in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_list_recent_issues") {
+        try {
+            const { owner, repo, state, sort, per_page } = ListRecentIssuesSchema.parse(args);
+
+            const issues = await octokit.rest.issues.listForRepo({
+                owner,
+                repo,
+                state: state || "open",
+                sort: sort || "created",
+                direction: "desc",
+                per_page: per_page || 30,
+            });
+
+            // Filter out pull requests (GitHub API returns both issues and PRs)
+            const actualIssues = issues.data.filter(issue => !issue.pull_request);
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                count: actualIssues.length,
+                                issues: actualIssues.map(issue => ({
+                                    number: issue.number,
+                                    title: issue.title,
+                                    state: issue.state,
+                                    user: issue.user?.login,
+                                    labels: issue.labels.map((l: any) => typeof l === "string" ? l : l.name),
+                                    created_at: issue.created_at,
+                                    updated_at: issue.updated_at,
+                                    comments: issue.comments,
+                                    html_url: issue.html_url,
+                                })),
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to list recent issues in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_merge_pr") {
+        try {
+            const { owner, repo, pull_number, merge_method, commit_title, commit_message } = MergePRSchema.parse(args);
+
+            const result = await octokit.rest.pulls.merge({
+                owner,
+                repo,
+                pull_number,
+                merge_method: merge_method as any,
+                commit_title,
+                commit_message,
+            });
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                success: true,
+                                merged: result.data.merged,
+                                sha: result.data.sha,
+                                message: result.data.message,
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const pullNum = args && typeof args === 'object' && 'pull_number' in args ? args.pull_number : 'unknown';
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to merge PR #${pullNum} in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_get_pr_diff") {
+        try {
+            const { owner, repo, pull_number } = GetPRDiffSchema.parse(args);
+
+            const diff = await octokit.rest.pulls.get({
+                owner,
+                repo,
+                pull_number,
+                mediaType: {
+                    format: "diff",
+                },
+            });
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                pull_number,
+                                diff: diff.data as any,
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const pullNum = args && typeof args === 'object' && 'pull_number' in args ? args.pull_number : 'unknown';
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to get diff for PR #${pullNum} in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
+    if (name === "github_get_pr_files") {
+        try {
+            const { owner, repo, pull_number } = GetPRFilesSchema.parse(args);
+
+            const files = await octokit.rest.pulls.listFiles({
+                owner,
+                repo,
+                pull_number,
+            });
+
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(
+                            {
+                                pull_number,
+                                total_files: files.data.length,
+                                files: files.data.map(file => ({
+                                    filename: file.filename,
+                                    status: file.status,
+                                    additions: file.additions,
+                                    deletions: file.deletions,
+                                    changes: file.changes,
+                                    blob_url: file.blob_url,
+                                    raw_url: file.raw_url,
+                                    patch: file.patch,
+                                })),
+                            },
+                            null,
+                            2
+                        ),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            const pullNum = args && typeof args === 'object' && 'pull_number' in args ? args.pull_number : 'unknown';
+            const owner = args && typeof args === 'object' && 'owner' in args ? args.owner : 'unknown';
+            const repo = args && typeof args === 'object' && 'repo' in args ? args.repo : 'unknown';
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: error.message,
+                            status: error.status,
+                            detail: `Failed to get files for PR #${pullNum} in ${owner}/${repo}`,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+
     throw new Error(`Unknown tool: ${name}`);
 });