@andrebuzeli/git-mcp 5.5.0 → 5.5.2

package/dist/tools/gitIssues.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitIssuesTool = void 0;
+const errors_1 = require("../utils/errors");
+class GitIssuesTool {
+    constructor() {
+        this.name = 'git-issues';
+        this.description = 'Issue management for GitHub and Gitea';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        const provider = params.provider;
+        if (!action)
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action is required');
+        if (!provider)
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'provider is required');
+        const owner = params.owner;
+        const repo = params.repo;
+        switch (action) {
+            case 'create': {
+                if (!params.title)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'title is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.issues.create({
+                        owner: owner || process.env.GITHUB_USERNAME,
+                        repo: repo,
+                        title: params.title,
+                        body: params.body,
+                        labels: params.labels,
+                        assignees: params.assignees,
+                        milestone: params.milestone,
+                    });
+                    return { success: true, issue: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const axios = require('axios');
+                    const result = await axios.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner || process.env.GITEA_USERNAME}/${repo}/issues`, {
+                        title: params.title,
+                        body: params.body,
+                        labels: params.labels?.map((l) => ({ name: l })),
+                        assignees: params.assignees,
+                    }, {
+                        headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                    });
+                    return { success: true, issue: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'list': {
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.issues.listForRepo({
+                        owner: owner || process.env.GITHUB_USERNAME,
+                        repo: repo,
+                        state: params.state_filter || 'open',
+                        sort: params.sort || 'created',
+                        direction: params.direction || 'desc',
+                        since: params.since,
+                    });
+                    return { success: true, issues: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const axios = require('axios');
+                    const result = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner || process.env.GITEA_USERNAME}/${repo}/issues`, {
+                        params: {
+                            state: params.state_filter || 'open',
+                            sort: params.sort || 'created',
+                            since: params.since,
+                        },
+                        headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                    });
+                    return { success: true, issues: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'get': {
+                const issue_number = params.issue_number;
+                if (!issue_number)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'issue_number is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.issues.get({
+                        owner: owner || process.env.GITHUB_USERNAME,
+                        repo: repo,
+                        issue_number,
+                    });
+                    return { success: true, issue: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const axios = require('axios');
+                    const result = await axios.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner || process.env.GITEA_USERNAME}/${repo}/issues/${issue_number}`, {
+                        headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                    });
+                    return { success: true, issue: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'update': {
+                const issue_number = params.issue_number;
+                if (!issue_number)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'issue_number is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.issues.update({
+                        owner: owner || process.env.GITHUB_USERNAME,
+                        repo: repo,
+                        issue_number,
+                        title: params.title,
+                        body: params.body,
+                        state: params.state,
+                        labels: params.labels,
+                        assignees: params.assignees,
+                        milestone: params.milestone,
+                    });
+                    return { success: true, issue: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const axios = require('axios');
+                    const result = await axios.patch(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner || process.env.GITEA_USERNAME}/${repo}/issues/${issue_number}`, {
+                        title: params.title,
+                        body: params.body,
+                        state: params.state,
+                    }, {
+                        headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                    });
+                    return { success: true, issue: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'close': {
+                const issue_number = params.issue_number;
+                if (!issue_number)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'issue_number is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.issues.update({
+                        owner: owner || process.env.GITHUB_USERNAME,
+                        repo: repo,
+                        issue_number,
+                        state: 'closed',
+                    });
+                    return { success: true, issue: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const axios = require('axios');
+                    const result = await axios.patch(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner || process.env.GITEA_USERNAME}/${repo}/issues/${issue_number}`, { state: 'closed' }, {
+                        headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                    });
+                    return { success: true, issue: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'comment': {
+                const issue_number = params.issue_number;
+                const comment_body = params.comment_body;
+                if (!issue_number)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'issue_number is required');
+                if (!comment_body)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'comment_body is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.issues.createComment({
+                        owner: owner || process.env.GITHUB_USERNAME,
+                        repo: repo,
+                        issue_number,
+                        body: comment_body,
+                    });
+                    return { success: true, comment: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const axios = require('axios');
+                    const result = await axios.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner || process.env.GITEA_USERNAME}/${repo}/issues/${issue_number}/comments`, { body: comment_body }, {
+                        headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                    });
+                    return { success: true, comment: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'search': {
+                const query = params.query;
+                if (!query)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'query is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.search.issuesAndPullRequests({
+                        q: `${query} repo:${owner || process.env.GITHUB_USERNAME}/${repo} type:issue`,
+                        sort: params.search_sort || 'created',
+                        order: params.search_order || 'desc',
+                    });
+                    return { success: true, issues: result.data.items };
+                }
+                throw new errors_1.MCPError('VALIDATION_ERROR', 'Search not fully implemented for Gitea');
+            }
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitIssuesTool = GitIssuesTool;

package/dist/tools/gitMonitor.d.ts

@@ -0,0 +1,51 @@
+import { Tool, MCPContext } from '../types';
+export declare class GitMonitorTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        commits: readonly (import("simple-git").DefaultLogFields & import("simple-git").ListLogLine)[];
+        total: number;
+        status?: undefined;
+        contributors?: undefined;
+    } | {
+        success: boolean;
+        status: import("simple-git").StatusResult | {
+            branch: string | null;
+            ahead: number;
+            behind: number;
+            staged: string[];
+            modified: string[];
+            deleted: string[];
+            created: string[];
+            renamed: import("simple-git").StatusResultRenamed[];
+            conflicted: string[];
+            not_added: string[];
+        };
+        commits?: undefined;
+        total?: undefined;
+        contributors?: undefined;
+    } | {
+        success: boolean;
+        commits: {
+            hash: string;
+            date: string;
+            message: string;
+            author: string;
+            email: string;
+        }[];
+        total?: undefined;
+        status?: undefined;
+        contributors?: undefined;
+    } | {
+        success: boolean;
+        contributors: {
+            name: string;
+            email: string;
+            commits: number;
+        }[];
+        commits?: undefined;
+        total?: undefined;
+        status?: undefined;
+    }>;
+}

package/dist/tools/gitMonitor.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitMonitorTool = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const errors_1 = require("../utils/errors");
+class GitMonitorTool {
+    constructor() {
+        this.name = 'git-monitor';
+        this.description = 'Repository monitoring and status operations';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        const projectPath = params.projectPath;
+        if (!action || !projectPath) {
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
+        }
+        const git = (0, simple_git_1.default)({ baseDir: projectPath });
+        switch (action) {
+            case 'log': {
+                const options = {
+                    maxCount: params.limit || 10,
+                };
+                if (params.since)
+                    options.from = params.since;
+                if (params.until)
+                    options.to = params.until;
+                if (params.author)
+                    options.author = params.author;
+                const log = await git.log(options);
+                return {
+                    success: true,
+                    commits: log.all,
+                    total: log.total,
+                };
+            }
+            case 'status': {
+                const status = await git.status();
+                const detailed = params.detailed ? {
+                    branch: status.current,
+                    ahead: status.ahead,
+                    behind: status.behind,
+                    staged: status.staged,
+                    modified: status.modified,
+                    deleted: status.deleted,
+                    created: status.created,
+                    renamed: status.renamed,
+                    conflicted: status.conflicted,
+                    not_added: status.not_added,
+                } : status;
+                return { success: true, status: detailed };
+            }
+            case 'commits': {
+                const branch = params.branch;
+                const options = {
+                    maxCount: params.limit || 50,
+                };
+                if (branch)
+                    options.from = branch;
+                if (params.since)
+                    options.from = params.since;
+                if (params.author)
+                    options.author = params.author;
+                const log = await git.log(options);
+                return {
+                    success: true,
+                    commits: log.all.map(c => ({
+                        hash: c.hash,
+                        date: c.date,
+                        message: c.message,
+                        author: c.author_name,
+                        email: c.author_email,
+                    })),
+                };
+            }
+            case 'contributors': {
+                const log = await git.log();
+                const contributors = new Map();
+                log.all.forEach(commit => {
+                    const key = commit.author_email;
+                    if (contributors.has(key)) {
+                        contributors.get(key).commits++;
+                    }
+                    else {
+                        contributors.set(key, {
+                            name: commit.author_name,
+                            email: commit.author_email,
+                            commits: 1,
+                        });
+                    }
+                });
+                const sorted = Array.from(contributors.values()).sort((a, b) => b.commits - a.commits);
+                return { success: true, contributors: sorted };
+            }
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitMonitorTool = GitMonitorTool;

package/dist/tools/gitPackages.d.ts

@@ -0,0 +1,6 @@
+import { Tool, MCPContext } from '../types';
+export declare class GitPackagesTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<void>;
+}

package/dist/tools/gitPackages.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitPackagesTool = void 0;
+const errors_1 = require("../utils/errors");
+class GitPackagesTool {
+    constructor() {
+        this.name = 'git-packages';
+        this.description = 'Package management operations';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        if (!action)
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action is required');
+        switch (action) {
+            case 'list':
+            case 'get':
+            case 'create':
+            case 'update':
+            case 'delete':
+            case 'publish':
+            case 'download':
+                throw new errors_1.MCPError('NOT_IMPLEMENTED', `Action ${action} not yet fully implemented`);
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitPackagesTool = GitPackagesTool;

package/dist/tools/gitPulls.d.ts

@@ -0,0 +1,74 @@
+import { Tool, MCPContext } from '../types';
+export declare class GitPullsTool implements Tool {
+    name: string;
+    description: string;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        pull: any;
+        pulls?: undefined;
+        merged?: undefined;
+        review?: undefined;
+    } | {
+        success: boolean;
+        pulls: any;
+        pull?: undefined;
+        merged?: undefined;
+        review?: undefined;
+    } | {
+        success: boolean;
+        merged: any;
+        pull?: undefined;
+        pulls?: undefined;
+        review?: undefined;
+    } | {
+        success: boolean;
+        review: {
+            id: number;
+            node_id: string;
+            user: {
+                name?: string | null;
+                email?: string | null;
+                login: string;
+                id: number;
+                node_id: string;
+                avatar_url: string;
+                gravatar_id: string | null;
+                url: string;
+                html_url: string;
+                followers_url: string;
+                following_url: string;
+                gists_url: string;
+                starred_url: string;
+                subscriptions_url: string;
+                organizations_url: string;
+                repos_url: string;
+                events_url: string;
+                received_events_url: string;
+                type: string;
+                site_admin: boolean;
+                starred_at?: string;
+                user_view_type?: string;
+            } | null;
+            body: string;
+            state: string;
+            html_url: string;
+            pull_request_url: string;
+            _links: {
+                html: {
+                    href: string;
+                };
+                pull_request: {
+                    href: string;
+                };
+            };
+            submitted_at?: string;
+            commit_id: string | null;
+            body_html?: string;
+            body_text?: string;
+            author_association: "COLLABORATOR" | "CONTRIBUTOR" | "FIRST_TIMER" | "FIRST_TIME_CONTRIBUTOR" | "MANNEQUIN" | "MEMBER" | "NONE" | "OWNER";
+        };
+        pull?: undefined;
+        pulls?: undefined;
+        merged?: undefined;
+    }>;
+}

package/dist/tools/gitPulls.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitPullsTool = void 0;
+const errors_1 = require("../utils/errors");
+const axios_1 = __importDefault(require("axios"));
+class GitPullsTool {
+    constructor() {
+        this.name = 'git-pulls';
+        this.description = 'Pull request management for GitHub and Gitea';
+    }
+    async handle(params, ctx) {
+        const action = params.action;
+        const provider = params.provider;
+        if (!action)
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'action is required');
+        if (!provider)
+            throw new errors_1.MCPError('VALIDATION_ERROR', 'provider is required');
+        const owner = params.owner || process.env.GITHUB_USERNAME || process.env.GITEA_USERNAME;
+        const repo = params.repo;
+        switch (action) {
+            case 'create': {
+                if (!params.title || !params.head || !params.base) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'title, head, and base are required');
+                }
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.pulls.create({
+                        owner: owner,
+                        repo: repo,
+                        title: params.title,
+                        head: params.head,
+                        base: params.base,
+                        body: params.body,
+                    });
+                    return { success: true, pull: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const result = await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner}/${repo}/pulls`, {
+                        title: params.title,
+                        head: params.head,
+                        base: params.base,
+                        body: params.body,
+                    }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                    return { success: true, pull: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'list': {
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.pulls.list({
+                        owner: owner,
+                        repo: repo,
+                        state: params.state_filter || 'open',
+                        sort: params.sort || 'created',
+                        direction: params.direction || 'desc',
+                    });
+                    return { success: true, pulls: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const result = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner}/${repo}/pulls`, {
+                        params: { state: params.state_filter || 'open' },
+                        headers: { Authorization: `token ${ctx.providerManager.giteaToken}` }
+                    });
+                    return { success: true, pulls: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'get': {
+                const pull_number = params.pull_number;
+                if (!pull_number)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'pull_number is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.pulls.get({
+                        owner: owner,
+                        repo: repo,
+                        pull_number,
+                    });
+                    return { success: true, pull: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const result = await axios_1.default.get(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner}/${repo}/pulls/${pull_number}`, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                    return { success: true, pull: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'update': {
+                const pull_number = params.pull_number;
+                if (!pull_number)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'pull_number is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.pulls.update({
+                        owner: owner,
+                        repo: repo,
+                        pull_number,
+                        title: params.title,
+                        body: params.body,
+                        state: params.state,
+                    });
+                    return { success: true, pull: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const result = await axios_1.default.patch(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner}/${repo}/pulls/${pull_number}`, { title: params.title, body: params.body }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                    return { success: true, pull: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'merge': {
+                const pull_number = params.pull_number;
+                if (!pull_number)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'pull_number is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.pulls.merge({
+                        owner: owner,
+                        repo: repo,
+                        pull_number,
+                        commit_title: params.commit_title,
+                        commit_message: params.commit_message,
+                        merge_method: params.merge_method || 'merge',
+                    });
+                    return { success: true, merged: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const result = await axios_1.default.post(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner}/${repo}/pulls/${pull_number}/merge`, {
+                        Do: params.merge_method || 'merge',
+                        MergeTitleField: params.commit_title,
+                        MergeMessageField: params.commit_message,
+                    }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                    return { success: true, merged: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'close': {
+                const pull_number = params.pull_number;
+                if (!pull_number)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'pull_number is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.pulls.update({
+                        owner: owner,
+                        repo: repo,
+                        pull_number,
+                        state: 'closed',
+                    });
+                    return { success: true, pull: result.data };
+                }
+                if (provider === 'gitea' && ctx.providerManager.giteaBaseUrl) {
+                    const result = await axios_1.default.patch(`${ctx.providerManager.giteaBaseUrl}/api/v1/repos/${owner}/${repo}/pulls/${pull_number}`, { state: 'closed' }, { headers: { Authorization: `token ${ctx.providerManager.giteaToken}` } });
+                    return { success: true, pull: result.data };
+                }
+                throw new errors_1.MCPError('PROVIDER_NOT_CONFIGURED', `Provider ${provider} is not configured`);
+            }
+            case 'review': {
+                const pull_number = params.pull_number;
+                const event = params.event;
+                if (!pull_number || !event) {
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'pull_number and event are required');
+                }
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.pulls.createReview({
+                        owner: owner,
+                        repo: repo,
+                        pull_number,
+                        event,
+                        body: params.review_body,
+                    });
+                    return { success: true, review: result.data };
+                }
+                throw new errors_1.MCPError('VALIDATION_ERROR', 'Review not fully implemented for Gitea');
+            }
+            case 'search': {
+                const query = params.query;
+                if (!query)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'query is required');
+                if (provider === 'github' && ctx.providerManager.github) {
+                    const result = await ctx.providerManager.github.rest.search.issuesAndPullRequests({
+                        q: `${query} repo:${owner}/${repo} type:pr`,
+                        sort: params.search_sort || 'created',
+                        order: params.search_order || 'desc',
+                    });
+                    return { success: true, pulls: result.data.items };
+                }
+                throw new errors_1.MCPError('VALIDATION_ERROR', 'Search not fully implemented for Gitea');
+            }
+            default:
+                throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
+        }
+    }
+}
+exports.GitPullsTool = GitPullsTool;