@ttpears/gitlab-mcp-server 1.7.2 → 1.8.0

package/dist/tools.js

@@ -81,10 +81,15 @@ const getProjectsTool = {
     inputSchema: withUserAuth(z.object({
         first: z.number().min(1).max(100).default(20).describe('Number of projects to retrieve'),
         after: z.string().optional().describe('Cursor for pagination'),
+        sort: z.string().optional().describe('Sort order (e.g., UPDATED_DESC, CREATED_DESC, CREATED_ASC). Defaults to UPDATED_DESC for recency.'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
-        const result = await client.getProjects(input.first, input.after, credentials);
+        const result = await client.getProjects(input.first, input.after, input.fetchAll, credentials, input.sort);
+        if (input.fetchAll) {
+            return result;
+        }
         return result.projects;
     },
 };
@@ -103,10 +108,15 @@ const getIssuesTool = {
         projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
         first: z.number().min(1).max(100).default(20).describe('Number of issues to retrieve'),
         after: z.string().optional().describe('Cursor for pagination'),
+        sort: z.string().optional().describe('Sort order (e.g., UPDATED_DESC, CREATED_DESC, CREATED_ASC). Defaults to UPDATED_DESC for recency.'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
-        const result = await client.getIssues(input.projectPath, input.first, input.after, credentials);
+        const result = await client.getIssues(input.projectPath, input.first, input.after, input.fetchAll, credentials, input.sort);
+        if (input.fetchAll) {
+            return result;
+        }
         if (!result || !result.project || !result.project.issues) {
             throw new Error('Project not found or issues are not accessible for the provided path');
         }
@@ -128,10 +138,15 @@ const getMergeRequestsTool = {
         projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
         first: z.number().min(1).max(100).default(20).describe('Number of merge requests to retrieve'),
         after: z.string().optional().describe('Cursor for pagination'),
+        sort: z.string().optional().describe('Sort order (e.g., UPDATED_DESC, CREATED_DESC, CREATED_ASC). Defaults to UPDATED_DESC for recency.'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
-        const result = await client.getMergeRequests(input.projectPath, input.first, input.after, credentials);
+        const result = await client.getMergeRequests(input.projectPath, input.first, input.after, input.fetchAll, credentials, input.sort);
+        if (input.fetchAll) {
+            return result;
+        }
         if (!result || !result.project || !result.project.mergeRequests) {
             throw new Error('Project not found or merge requests are not accessible for the provided path');
         }
@@ -245,21 +260,6 @@ const getAvailableQueriesTools = {
         };
     },
 };
-export const readOnlyTools = [
-    getProjectTool,
-    getIssuesTool,
-    getMergeRequestsTool,
-    executeCustomQueryTool,
-    getAvailableQueriesTools,
-];
-export const userAuthTools = [
-    getCurrentUserTool,
-    getProjectsTool,
-];
-export const writeTools = [
-    createIssueTool,
-    createMergeRequestTool,
-];
 const updateIssueTool = {
     name: 'update_issue',
     title: 'Update Issue',
@@ -410,15 +410,27 @@ const globalSearchTool = {
     },
     inputSchema: withUserAuth(z.object({
         searchTerm: z.string().optional().transform(val => val?.trim() || undefined).describe('Search term (leave empty for recent activity)'),
+        first: z.number().min(1).max(100).default(20).describe('Number of results to retrieve per category'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results per category'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
-        const result = await client.globalSearch(input.searchTerm, undefined, credentials);
+        if (input.fetchAll) {
+            const result = await client.globalSearchAll(input.searchTerm, undefined, credentials);
+            return {
+                searchTerm: input.searchTerm,
+                projects: result.projects,
+                issues: result.issues,
+                totalResults: result.projects.totalFetched + result.issues.totalFetched,
+            };
+        }
+        const result = await client.globalSearch(input.searchTerm, input.first, input.after, credentials);
         return {
             searchTerm: input.searchTerm,
-            projects: result.projects.nodes,
-            issues: result.issues.nodes,
-            totalResults: result.projects.nodes.length + result.issues.nodes.length,
+            projects: result.projects,
+            issues: result.issues,
+            totalResults: (result.projects.nodes?.length || 0) + (result.issues.nodes?.length || 0),
             _note: 'This is a text search only. For filtering by assignee/author/labels, use search_issues or get_user_issues. For MRs, use search_merge_requests with username.'
         };
     },
@@ -441,10 +453,14 @@ const searchProjectsTool = {
             .describe('Search term to find projects by name or description'),
         first: z.number().min(1).max(100).default(20).describe('Number of projects to retrieve'),
         after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
-        const result = await client.searchProjects(input.searchTerm, input.first, input.after, credentials);
+        const result = await client.searchProjects(input.searchTerm, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
         return result.projects;
     },
 };
@@ -468,10 +484,15 @@ const searchIssuesTool = {
         labelNames: z.array(z.string()).optional().describe('Filter by label names (e.g., ["Priority::High", "bug"])'),
         first: z.number().min(1).max(100).default(20).describe('Number of issues to retrieve'),
         after: z.string().optional().describe('Cursor for pagination'),
+        sort: z.string().optional().describe('Sort order (e.g., UPDATED_DESC, CREATED_DESC, CREATED_ASC). Defaults to UPDATED_DESC for recency.'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
-        const result = await client.searchIssues(input.searchTerm, input.projectPath, input.state, input.first, input.after, credentials, input.assigneeUsernames, input.authorUsername, input.labelNames);
+        const result = await client.searchIssues(input.searchTerm, input.projectPath, input.state, input.first, input.after, input.fetchAll, credentials, input.assigneeUsernames, input.authorUsername, input.labelNames, input.sort);
+        if (input.fetchAll) {
+            return result;
+        }
         // Return the issues from either project-specific or global search
         if (input.projectPath) {
             if (!result || !result.project || !result.project.issues) {
@@ -512,12 +533,17 @@ const searchMergeRequestsTool = {
         state: z.string().default('all').describe('Filter by merge request state (opened, closed, merged, all)'),
         first: z.number().min(1).max(100).default(20).describe('Number of merge requests to retrieve'),
         after: z.string().optional().describe('Cursor for pagination'),
+        sort: z.string().optional().describe('Sort order (e.g., UPDATED_DESC, CREATED_DESC, CREATED_ASC). Defaults to UPDATED_DESC for recency.'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
         // If projectPath provided, search in that project
         // Otherwise, intelligently find projects matching search term and search their MRs
-        const result = await client.searchMergeRequests(input.searchTerm, input.projectPath, input.state, input.first, input.after, credentials);
+        const result = await client.searchMergeRequests(input.searchTerm, input.projectPath, input.state, input.first, input.after, input.fetchAll, credentials, input.sort);
+        if (input.fetchAll) {
+            return result;
+        }
         // Handle project-specific search
         if (input.projectPath) {
             if (!result || !result.project || !result.project.mergeRequests) {
@@ -553,10 +579,15 @@ const searchUsersTool = {
             .refine(val => val.length > 0, { message: 'Search term cannot be empty' })
             .describe('Search term to find users by username or name'),
         first: z.number().min(1).max(100).default(20).describe('Number of users to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
-        const result = await client.searchUsers(input.searchTerm, input.first, credentials);
+        const result = await client.searchUsers(input.searchTerm, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
         return result.users;
     },
 };
@@ -577,10 +608,15 @@ const searchGroupsTool = {
             .refine(val => val.length > 0, { message: 'Search term cannot be empty' })
             .describe('Search term to find groups by name or path'),
         first: z.number().min(1).max(100).default(20).describe('Number of groups to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
-        const result = await client.searchGroups(input.searchTerm, input.first, credentials);
+        const result = await client.searchGroups(input.searchTerm, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
         return result.groups;
     },
 };
@@ -660,6 +696,461 @@ const getFileContentTool = {
         };
     },
 };
+// CI/CD Pipeline tools
+const getMergeRequestPipelinesTool = {
+    name: 'get_merge_request_pipelines',
+    title: 'MR Pipelines',
+    description: 'Get CI/CD pipelines for a merge request, including status, duration, and stages',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        iid: z.string().describe('Merge request IID'),
+        first: z.number().min(1).max(100).default(20).describe('Number of pipelines to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.getMergeRequestPipelines(input.projectPath, input.iid, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
+        if (!result?.project?.mergeRequest) {
+            throw new Error('Merge request not found');
+        }
+        return result.project.mergeRequest.pipelines;
+    },
+};
+const getPipelineJobsTool = {
+    name: 'get_pipeline_jobs',
+    title: 'Pipeline Jobs',
+    description: 'Get jobs for a specific pipeline, including status, stage, duration, and retry/cancel info',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        pipelineIid: z.string().describe('Pipeline IID'),
+        first: z.number().min(1).max(100).default(20).describe('Number of jobs to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.getPipelineJobs(input.projectPath, input.pipelineIid, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
+        if (!result?.project?.pipeline) {
+            throw new Error('Pipeline not found');
+        }
+        return {
+            pipeline: {
+                id: result.project.pipeline.id,
+                iid: result.project.pipeline.iid,
+                status: result.project.pipeline.status,
+            },
+            jobs: result.project.pipeline.jobs,
+        };
+    },
+};
+const managePipelineTool = {
+    name: 'manage_pipeline',
+    title: 'Manage Pipeline',
+    description: 'Retry or cancel a CI/CD pipeline (requires user authentication with write permissions)',
+    requiresAuth: true,
+    requiresWrite: true,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        pipelineIid: z.string().describe('Pipeline IID'),
+        action: z.enum(['retry', 'cancel']).describe('Action to perform on the pipeline'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        if (!credentials) {
+            throw new Error('User authentication is required for pipeline management. Please provide your GitLab credentials.');
+        }
+        return await client.managePipeline(input.projectPath, input.pipelineIid, input.action, credentials);
+    },
+};
+// MR Diffs & Commits tools
+const getMergeRequestDiffsTool = {
+    name: 'get_merge_request_diffs',
+    title: 'MR Diffs',
+    description: 'Get diff statistics for a merge request, including per-file additions/deletions and diff refs',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        iid: z.string().describe('Merge request IID'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.getMergeRequestDiffs(input.projectPath, input.iid, credentials);
+        if (!result?.project?.mergeRequest) {
+            throw new Error('Merge request not found');
+        }
+        return result.project.mergeRequest;
+    },
+};
+const getMergeRequestCommitsTool = {
+    name: 'get_merge_request_commits',
+    title: 'MR Commits',
+    description: 'Get commits for a merge request (excluding merge commits), with commit count and details',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        iid: z.string().describe('Merge request IID'),
+        first: z.number().min(1).max(100).default(20).describe('Number of commits to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.getMergeRequestCommits(input.projectPath, input.iid, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
+        if (!result?.project?.mergeRequest) {
+            throw new Error('Merge request not found');
+        }
+        return {
+            commitCount: result.project.mergeRequest.commitCount,
+            commits: result.project.mergeRequest.commitsWithoutMergeCommits,
+        };
+    },
+};
+// Work Item Notes tools
+const getNotesTool = {
+    name: 'get_notes',
+    title: 'Notes/Comments',
+    description: 'Get notes (comments) on an issue or merge request, including system notes and inline MR comments',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        noteableType: z.enum(['issue', 'merge_request']).describe('Type of item to get notes for'),
+        iid: z.string().describe('Issue or merge request IID'),
+        first: z.number().min(1).max(100).default(20).describe('Number of notes to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.getNotes(input.projectPath, input.noteableType, input.iid, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
+        const noteable = input.noteableType === 'issue'
+            ? result?.project?.issue
+            : result?.project?.mergeRequest;
+        if (!noteable) {
+            throw new Error(`${input.noteableType === 'issue' ? 'Issue' : 'Merge request'} not found`);
+        }
+        return noteable.notes;
+    },
+};
+const createNoteTool = {
+    name: 'create_note',
+    title: 'Create Note',
+    description: 'Add a comment/note to an issue or merge request (requires user authentication)',
+    requiresAuth: true,
+    requiresWrite: true,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        noteableType: z.enum(['issue', 'merge_request']).describe('Type of item to add a note to'),
+        iid: z.string().describe('Issue or merge request IID'),
+        body: z.string().min(1).describe('Note body (supports Markdown)'),
+        internal: z.boolean().default(false).describe('Whether the note is internal/confidential (only visible to project members)'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        if (!credentials) {
+            throw new Error('User authentication is required for creating notes. Please provide your GitLab credentials.');
+        }
+        const result = await client.createNote(input.projectPath, input.noteableType, input.iid, input.body, input.internal, credentials);
+        if (result.errors && result.errors.length > 0) {
+            throw new Error(`Failed to create note: ${result.errors.join(', ')}`);
+        }
+        return result.note;
+    },
+};
+// ── Project Tracking & User Reporting tools ─────────────────────────
+const listMilestonesTool = {
+    name: 'list_milestones',
+    title: 'Milestones',
+    description: 'List milestones for a project or group with progress statistics (total/closed issue counts)',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        fullPath: z.string().describe('Full path of the project or group (e.g., "group/project-name" or "group")'),
+        isProject: z.boolean().describe('Whether the path is a project (true) or group (false)'),
+        state: z.string().optional().describe('Filter by state: active, closed (omit for all)'),
+        search: z.string().optional().describe('Search milestones by title'),
+        includeAncestors: z.boolean().default(false).describe('Include milestones from ancestor groups'),
+        first: z.number().min(1).max(100).default(20).describe('Number of milestones to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.listMilestones(input.fullPath, input.isProject, input.state, input.search, input.includeAncestors, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
+        const container = input.isProject ? result?.project : result?.group;
+        if (!container) {
+            throw new Error(`${input.isProject ? 'Project' : 'Group'} not found: ${input.fullPath}`);
+        }
+        return container.milestones;
+    },
+};
+const listIterationsTool = {
+    name: 'list_iterations',
+    title: 'Iterations',
+    description: 'List iterations (sprints) for a group with cadence info. Requires GitLab Premium/Ultimate.',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        groupPath: z.string().describe('Full path of the group (e.g., "my-group" or "parent/child-group")'),
+        state: z.string().optional().describe('Filter by state: upcoming, current, opened, closed (omit for all)'),
+        first: z.number().min(1).max(100).default(20).describe('Number of iterations to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        try {
+            const result = await client.listIterations(input.groupPath, input.state, input.first, input.after, input.fetchAll, credentials);
+            if (input.fetchAll) {
+                return result;
+            }
+            if (!result?.group) {
+                throw new Error(`Group not found: ${input.groupPath}`);
+            }
+            return result.group.iterations;
+        }
+        catch (error) {
+            if (error.message?.includes('iterations') || error.message?.includes('does not exist')) {
+                throw new Error(`Iterations are not available for "${input.groupPath}". ` +
+                    `This feature requires GitLab Premium or Ultimate. ` +
+                    `Original error: ${error.message}`);
+            }
+            throw error;
+        }
+    },
+};
+const getTimeTrackingTool = {
+    name: 'get_time_tracking',
+    title: 'Time Tracking',
+    description: 'Get time tracking data (estimate, spent, timelogs) for an issue or merge request',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        resourceType: z.enum(['issue', 'merge_request']).describe('Type of resource to get time tracking for'),
+        iid: z.string().describe('Issue or merge request IID'),
+        includeTimelogs: z.boolean().default(true).describe('Whether to include individual timelog entries'),
+        first: z.number().min(1).max(100).default(20).describe('Number of timelog entries to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.getTimeTracking(input.projectPath, input.resourceType, input.iid, input.includeTimelogs, input.first, input.after, credentials);
+        const resource = input.resourceType === 'issue'
+            ? result?.project?.issue
+            : result?.project?.mergeRequest;
+        if (!resource) {
+            throw new Error(`${input.resourceType === 'issue' ? 'Issue' : 'Merge request'} not found`);
+        }
+        return resource;
+    },
+};
+const getMergeRequestReviewersTool = {
+    name: 'get_merge_request_reviewers',
+    title: 'MR Reviewers',
+    description: 'Get approval and reviewer status for a merge request, including who approved and review states',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+        iid: z.string().describe('Merge request IID'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.getMergeRequestReviewers(input.projectPath, input.iid, credentials);
+        if (!result?.project?.mergeRequest) {
+            throw new Error('Merge request not found');
+        }
+        return result.project.mergeRequest;
+    },
+};
+const getProjectStatisticsTool = {
+    name: 'get_project_statistics',
+    title: 'Project Statistics',
+    description: 'Get aggregate project statistics: open issues/MRs, star/fork counts, storage sizes, commit count, last pipeline status, release count, and language breakdown',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        projectPath: z.string().describe('Full path of the project (e.g., "group/project-name")'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.getProjectStatistics(input.projectPath, credentials);
+        if (!result?.project) {
+            throw new Error(`Project not found: ${input.projectPath}`);
+        }
+        const p = result.project;
+        return {
+            id: p.id,
+            name: p.name,
+            fullPath: p.fullPath,
+            webUrl: p.webUrl,
+            starCount: p.starCount,
+            forksCount: p.forksCount,
+            openIssuesCount: p.openIssuesCount,
+            openMergeRequestsCount: p.openMergeRequests?.count ?? null,
+            commitCount: p.statistics?.commitCount ?? null,
+            storage: p.statistics ? {
+                repositorySize: p.statistics.repositorySize,
+                lfsObjectsSize: p.statistics.lfsObjectsSize,
+                buildArtifactsSize: p.statistics.buildArtifactsSize,
+                packagesSize: p.statistics.packagesSize,
+                wikiSize: p.statistics.wikiSize,
+                snippetsSize: p.statistics.snippetsSize,
+                uploadsSize: p.statistics.uploadsSize,
+                containerRegistrySize: p.statistics.containerRegistrySize,
+            } : null,
+            lastPipeline: p.lastPipeline?.nodes?.[0] ?? null,
+            releaseCount: p.releaseCount?.count ?? null,
+            languages: p.languages ?? [],
+        };
+    },
+};
+const listGroupMembersTool = {
+    name: 'list_group_members',
+    title: 'Group Members',
+    description: 'List group members with access levels, optionally filtered by search term',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        groupPath: z.string().describe('Full path of the group (e.g., "my-group" or "parent/child-group")'),
+        search: z.string().optional().describe('Optional search term to filter members by name or username'),
+        first: z.number().min(1).max(100).default(20).describe('Number of members to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.listGroupMembers(input.groupPath, input.search, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
+        if (!result?.group) {
+            throw new Error(`Group not found: ${input.groupPath}`);
+        }
+        return result.group.groupMembers;
+    },
+};
+// Label Search tool
+const searchLabelsTool = {
+    name: 'search_labels',
+    title: 'Search Labels',
+    description: 'Search for labels in a project or group, with optional text filtering',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: withUserAuth(z.object({
+        fullPath: z.string().describe('Full path of the project or group (e.g., "group/project-name" or "group")'),
+        isProject: z.boolean().describe('Whether the path is a project (true) or group (false)'),
+        search: z.string().optional().describe('Optional search term to filter labels'),
+        first: z.number().min(1).max(100).default(20).describe('Number of labels to retrieve'),
+        after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        const result = await client.searchLabels(input.fullPath, input.isProject, input.search, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
+        const container = input.isProject ? result?.project : result?.group;
+        if (!container) {
+            throw new Error(`${input.isProject ? 'Project' : 'Group'} not found: ${input.fullPath}`);
+        }
+        return container.labels;
+    },
+};
 // Helper functions for common user queries
 const getUserIssuesTool = {
     name: 'get_user_issues',
@@ -676,17 +1167,21 @@ const getUserIssuesTool = {
         username: z.string().describe('Username to find issues for (e.g., "cdhanlon")'),
         state: z.string().default('opened').describe('Filter by issue state (opened, closed, all)'),
         projectPath: z.string().optional().describe('Optional: limit search to a specific project'),
-        first: z.number().min(1).max(100).default(50).describe('Number of issues to retrieve'),
+        first: z.number().min(1).max(100).default(20).describe('Number of issues to retrieve'),
         after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
         // Use the searchIssues method with assigneeUsernames filter
         const result = await client.searchIssues(undefined, // No text search
-        input.projectPath, input.state, input.first, input.after, credentials, [input.username], // assigneeUsernames
+        input.projectPath, input.state, input.first, input.after, input.fetchAll, credentials, [input.username], // assigneeUsernames
         undefined, // authorUsername
         undefined // labelNames
         );
+        if (input.fetchAll) {
+            return result;
+        }
         if (input.projectPath) {
             if (!result || !result.project || !result.project.issues) {
                 throw new Error('Project not found or issues are not accessible for the provided path');
@@ -723,14 +1218,18 @@ const getUserMergeRequestsTool = {
         role: z.enum(['author', 'assignee']).default('author').describe('Whether to find MRs authored by or assigned to the user'),
         state: z.string().default('opened').describe('Filter by MR state (opened, closed, merged, all)'),
         projectPath: z.string().optional().describe('Optional: limit search to a specific project'),
-        first: z.number().min(1).max(100).default(50).describe('Number of merge requests to retrieve'),
+        first: z.number().min(1).max(100).default(20).describe('Number of merge requests to retrieve'),
         after: z.string().optional().describe('Cursor for pagination'),
+        fetchAll: z.boolean().default(false).describe('Fetch all pages up to 100 results'),
     })),
     handler: async (input, client, userConfig) => {
         const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
         // Use the searchMergeRequests method with author: or assignee: prefix
         const searchTerm = input.role === 'author' ? `author:${input.username}` : `assignee:${input.username}`;
-        const result = await client.searchMergeRequests(searchTerm, input.projectPath, input.state, input.first, input.after, credentials);
+        const result = await client.searchMergeRequests(searchTerm, input.projectPath, input.state, input.first, input.after, input.fetchAll, credentials);
+        if (input.fetchAll) {
+            return result;
+        }
         if (input.projectPath) {
             if (!result || !result.project || !result.project.mergeRequests) {
                 throw new Error(`Project "${input.projectPath}" not found or merge requests are not accessible`);
@@ -751,6 +1250,146 @@ const getUserMergeRequestsTool = {
         };
     },
 };
+const BroadcastMessageFields = {
+    message: z.string().min(1).describe('Message text to display'),
+    starts_at: z.string().datetime().optional().describe('ISO 8601 timestamp when the message starts'),
+    ends_at: z.string().datetime().optional().describe('ISO 8601 timestamp when the message ends'),
+    color: z.string().optional().describe('Background color in hex format, e.g. "#E75E40"'),
+    font: z.string().optional().describe('Foreground (font) color in hex format'),
+    target_access_levels: z.array(z.number().int()).optional().describe('Access levels to target: 10=Guest, 20=Reporter, 30=Developer, 40=Maintainer, 50=Owner'),
+    target_path: z.string().optional().describe('Path glob for pages where the message should appear'),
+    broadcast_type: z.enum(['banner', 'notification']).optional().describe('Broadcast type: "banner" or "notification"'),
+    dismissable: z.boolean().optional().describe('Whether users can dismiss the broadcast message'),
+    theme: z.string().optional().describe('Theme name (GitLab 16.9+), e.g. "indigo", "red"'),
+};
+const listBroadcastMessagesTool = {
+    name: 'list_broadcast_messages',
+    title: 'List Broadcast Messages',
+    description: 'List all GitLab broadcast messages (instance-wide announcements). Read-only.',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    inputSchema: withUserAuth(z.object({
+        page: z.number().int().min(1).default(1).describe('Page number (1-based)'),
+        perPage: z.number().int().min(1).max(100).default(20).describe('Results per page'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        return client.listBroadcastMessages(input.page, input.perPage, credentials);
+    },
+};
+const getBroadcastMessageTool = {
+    name: 'get_broadcast_message',
+    title: 'Get Broadcast Message',
+    description: 'Get a specific GitLab broadcast message by ID.',
+    requiresAuth: false,
+    requiresWrite: false,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    inputSchema: withUserAuth(z.object({
+        id: z.number().int().describe('Broadcast message ID'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        return client.getBroadcastMessage(input.id, credentials);
+    },
+};
+const createBroadcastMessageTool = {
+    name: 'create_broadcast_message',
+    title: 'Create Broadcast Message',
+    description: 'Create a GitLab broadcast message. Requires administrator privileges on the GitLab instance.',
+    requiresAuth: true,
+    requiresWrite: true,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+    inputSchema: withUserAuth(z.object(BroadcastMessageFields)),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        if (!credentials) {
+            throw new Error('User authentication is required for creating broadcast messages.');
+        }
+        const { userCredentials, ...body } = input;
+        return client.createBroadcastMessage(body, credentials);
+    },
+};
+const updateBroadcastMessageTool = {
+    name: 'update_broadcast_message',
+    title: 'Update Broadcast Message',
+    description: 'Update an existing GitLab broadcast message. Requires administrator privileges.',
+    requiresAuth: true,
+    requiresWrite: true,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+    inputSchema: withUserAuth(z.object({
+        id: z.number().int().describe('Broadcast message ID'),
+        message: BroadcastMessageFields.message.optional(),
+        starts_at: BroadcastMessageFields.starts_at,
+        ends_at: BroadcastMessageFields.ends_at,
+        color: BroadcastMessageFields.color,
+        font: BroadcastMessageFields.font,
+        target_access_levels: BroadcastMessageFields.target_access_levels,
+        target_path: BroadcastMessageFields.target_path,
+        broadcast_type: BroadcastMessageFields.broadcast_type,
+        dismissable: BroadcastMessageFields.dismissable,
+        theme: BroadcastMessageFields.theme,
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        if (!credentials) {
+            throw new Error('User authentication is required for updating broadcast messages.');
+        }
+        const { id, userCredentials, ...body } = input;
+        return client.updateBroadcastMessage(id, body, credentials);
+    },
+};
+const deleteBroadcastMessageTool = {
+    name: 'delete_broadcast_message',
+    title: 'Delete Broadcast Message',
+    description: 'Delete a GitLab broadcast message by ID. Requires administrator privileges.',
+    requiresAuth: true,
+    requiresWrite: true,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
+    inputSchema: withUserAuth(z.object({
+        id: z.number().int().describe('Broadcast message ID'),
+    })),
+    handler: async (input, client, userConfig) => {
+        const credentials = input.userCredentials ? validateUserConfig(input.userCredentials) : userConfig;
+        if (!credentials) {
+            throw new Error('User authentication is required for deleting broadcast messages.');
+        }
+        await client.deleteBroadcastMessage(input.id, credentials);
+        return { id: input.id, deleted: true };
+    },
+};
+export const readOnlyTools = [
+    getProjectTool,
+    getIssuesTool,
+    getMergeRequestsTool,
+    executeCustomQueryTool,
+    getAvailableQueriesTools,
+    getMergeRequestPipelinesTool,
+    getPipelineJobsTool,
+    getMergeRequestDiffsTool,
+    getMergeRequestCommitsTool,
+    getNotesTool,
+    listMilestonesTool,
+    listIterationsTool,
+    getTimeTrackingTool,
+    getMergeRequestReviewersTool,
+    getProjectStatisticsTool,
+    listBroadcastMessagesTool,
+    getBroadcastMessageTool,
+];
+export const userAuthTools = [
+    getCurrentUserTool,
+    getProjectsTool,
+];
+export const writeTools = [
+    createIssueTool,
+    createMergeRequestTool,
+    createNoteTool,
+    managePipelineTool,
+    createBroadcastMessageTool,
+    updateBroadcastMessageTool,
+    deleteBroadcastMessageTool,
+];
 export const searchTools = [
     globalSearchTool,
     searchProjectsTool,
@@ -760,8 +1399,10 @@ export const searchTools = [
     getUserMergeRequestsTool,
     searchUsersTool,
     searchGroupsTool,
+    searchLabelsTool,
     browseRepositoryTool,
     getFileContentTool,
+    listGroupMembersTool,
 ];
 export const tools = [
     ...readOnlyTools,