@ttpears/gitlab-mcp-server 1.7.3 → 1.8.0

package/dist/gitlab-client.js

@@ -192,6 +192,35 @@ export class GitLabGraphQLClient {
         const client = this.getClient(userConfig, requiresWrite);
         return this.executeWithRetry(() => client.request(query, variables), 'GraphQL query');
     }
+    async fetchAllPages(query, variables, connectionPath, options = {}) {
+        const maxItems = options.maxItems ?? 100;
+        const pageSize = Math.min(options.pageSize ?? 50, this.config.maxPageSize);
+        const allNodes = [];
+        let after = undefined;
+        let lastPageInfo = { hasNextPage: false, hasPreviousPage: false, startCursor: null, endCursor: null };
+        while (allNodes.length < maxItems) {
+            const remaining = maxItems - allNodes.length;
+            const currentPageSize = Math.min(pageSize, remaining);
+            const result = await this.query(query, { ...variables, first: currentPageSize, after }, options.userConfig);
+            // Navigate to the connection using the dot-separated path
+            const connection = connectionPath.split('.').reduce((obj, key) => obj?.[key], result);
+            if (!connection || !connection.nodes) {
+                break;
+            }
+            allNodes.push(...connection.nodes);
+            lastPageInfo = connection.pageInfo || lastPageInfo;
+            if (!lastPageInfo.hasNextPage || allNodes.length >= maxItems) {
+                break;
+            }
+            after = lastPageInfo.endCursor ?? undefined;
+        }
+        return {
+            nodes: allNodes,
+            totalFetched: allNodes.length,
+            hasMore: lastPageInfo.hasNextPage && allNodes.length >= maxItems,
+            pageInfo: lastPageInfo,
+        };
+    }
     async getCurrentUser(userConfig) {
         const query = gql `
       query getCurrentUser {
@@ -233,10 +262,10 @@ export class GitLabGraphQLClient {
     `;
         return this.query(query, { fullPath }, userConfig);
     }
-    async getProjects(first = 20, after, userConfig) {
+    async getProjects(first = 20, after, fetchAll = false, userConfig, sort) {
         const query = gql `
-      query getProjects($first: Int!, $after: String) {
-        projects(first: $first, after: $after) {
+      query getProjects($first: Int!, $after: String, $sort: String) {
+        projects(first: $first, after: $after, sort: $sort) {
             pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
             nodes {
               id
@@ -249,13 +278,20 @@ export class GitLabGraphQLClient {
           }
       }
     `;
-        return this.query(query, { first: Math.min(first, 50), after }, userConfig);
+        if (fetchAll) {
+            return this.fetchAllPages(query, { sort }, 'projects', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { first: Math.min(first, this.config.maxPageSize), after, sort }, userConfig);
     }
-    async getIssues(projectPath, first = 20, after, userConfig) {
+    async getIssues(projectPath, first = 20, after, fetchAll = false, userConfig, sort) {
         const query = gql `
-      query getIssues($projectPath: ID!, $first: Int!, $after: String) {
+      query getIssues($projectPath: ID!, $first: Int!, $after: String, $sort: IssueSort) {
         project(fullPath: $projectPath) {
-          issues(first: $first, after: $after) {
+          issues(first: $first, after: $after, sort: $sort) {
             pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
             nodes {
               id
@@ -271,13 +307,20 @@ export class GitLabGraphQLClient {
         }
       }
     `;
-        return this.query(query, { projectPath, first: Math.min(first, 50), after }, userConfig);
+        if (fetchAll) {
+            return this.fetchAllPages(query, { projectPath, sort: sort || 'UPDATED_DESC' }, 'project.issues', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { projectPath, first: Math.min(first, this.config.maxPageSize), after, sort: sort || 'UPDATED_DESC' }, userConfig);
     }
-    async getMergeRequests(projectPath, first = 20, after, userConfig) {
+    async getMergeRequests(projectPath, first = 20, after, fetchAll = false, userConfig, sort) {
         const query = gql `
-      query getMergeRequests($projectPath: ID!, $first: Int!, $after: String) {
+      query getMergeRequests($projectPath: ID!, $first: Int!, $after: String, $sort: MergeRequestSort) {
         project(fullPath: $projectPath) {
-          mergeRequests(first: $first, after: $after) {
+          mergeRequests(first: $first, after: $after, sort: $sort) {
             pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
             nodes {
               id
@@ -296,7 +339,14 @@ export class GitLabGraphQLClient {
         }
       }
     `;
-        return this.query(query, { projectPath, first: Math.min(first, 50), after }, userConfig);
+        if (fetchAll) {
+            return this.fetchAllPages(query, { projectPath, sort: sort || 'UPDATED_DESC' }, 'project.mergeRequests', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { projectPath, first: Math.min(first, this.config.maxPageSize), after, sort: sort || 'UPDATED_DESC' }, userConfig);
     }
     async createIssue(projectPath, title, description, userConfig) {
         await this.introspectSchema(userConfig);
@@ -623,10 +673,11 @@ export class GitLabGraphQLClient {
         const fields = type.getFields();
         return Object.keys(fields);
     }
-    async globalSearch(searchTerm, scope, userConfig) {
+    async globalSearch(searchTerm, first = 20, after, userConfig) {
         const query = gql `
-      query globalSearch($search: String, $first: Int!) {
-        projects(search: $search, first: $first) {
+      query globalSearch($search: String, $first: Int!, $after: String) {
+        projects(search: $search, first: $first, after: $after) {
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
           nodes {
             id
             name
@@ -635,7 +686,8 @@ export class GitLabGraphQLClient {
             visibility
           }
         }
-        issues(search: $search, first: $first) {
+        issues(search: $search, first: $first, after: $after) {
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
           nodes {
             id
             iid
@@ -649,10 +701,34 @@ export class GitLabGraphQLClient {
     `;
         return this.query(query, {
             search: searchTerm || undefined,
-            first: Math.min(this.config.maxPageSize, 25)
+            first: Math.min(first, this.config.maxPageSize),
+            after
         }, userConfig);
     }
-    async searchProjects(searchTerm, first = 20, after, userConfig) {
+    async globalSearchAll(searchTerm, maxItems = 100, userConfig) {
+        const projectsQuery = gql `
+      query globalSearchProjects($search: String, $first: Int!, $after: String) {
+        projects(search: $search, first: $first, after: $after) {
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+          nodes { id name fullPath webUrl visibility }
+        }
+      }
+    `;
+        const issuesQuery = gql `
+      query globalSearchIssues($search: String, $first: Int!, $after: String) {
+        issues(search: $search, first: $first, after: $after) {
+          pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+          nodes { id iid title state webUrl createdAt }
+        }
+      }
+    `;
+        const [projects, issues] = await Promise.all([
+            this.fetchAllPages(projectsQuery, { search: searchTerm || undefined }, 'projects', { maxItems, userConfig }),
+            this.fetchAllPages(issuesQuery, { search: searchTerm || undefined }, 'issues', { maxItems, userConfig }),
+        ]);
+        return { projects, issues };
+    }
+    async searchProjects(searchTerm, first = 20, after, fetchAll = false, userConfig) {
         const query = gql `
       query searchProjects($search: String!, $first: Int!, $after: String) {
         projects(search: $search, first: $first, after: $after) {
@@ -669,7 +745,14 @@ export class GitLabGraphQLClient {
         }
       }
     `;
-        return this.query(query, { search: searchTerm, first: Math.min(first, 50), after }, userConfig);
+        if (fetchAll) {
+            return this.fetchAllPages(query, { search: searchTerm }, 'projects', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { search: searchTerm, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
     }
     getTypeName(t) {
         if (!t)
@@ -683,7 +766,7 @@ export class GitLabGraphQLClient {
         const values = (enumType && typeof enumType.getValues === 'function') ? enumType.getValues() : [];
         return Array.isArray(values) ? values.map((v) => v.name) : [];
     }
-    async searchIssues(searchTerm, projectPath, state, first = 20, after, userConfig, assigneeUsernames, authorUsername, labelNames) {
+    async searchIssues(searchTerm, projectPath, state, first = 20, after, fetchAll = false, userConfig, assigneeUsernames, authorUsername, labelNames, sort) {
         await this.introspectSchema(userConfig);
         const mappedState = state && state.toLowerCase() !== 'all' ? state.toUpperCase() : undefined;
         if (projectPath) {
@@ -697,9 +780,9 @@ export class GitLabGraphQLClient {
                 ? (allowed.find(v => v.toLowerCase() === state.toLowerCase()) || undefined)
                 : undefined;
             const query = gql `
-        query searchIssuesProject($projectPath: ID!, $search: String, $state: ${stateEnum}, $first: Int!, $after: String, $assigneeUsernames: [String!], $authorUsername: String, $labelName: [String!]) {
+        query searchIssuesProject($projectPath: ID!, $search: String, $state: ${stateEnum}, $first: Int!, $after: String, $assigneeUsernames: [String!], $authorUsername: String, $labelName: [String!], $sort: IssueSort) {
           project(fullPath: $projectPath) {
-            issues(search: $search, state: $state, first: $first, after: $after, assigneeUsernames: $assigneeUsernames, authorUsername: $authorUsername, labelName: $labelName) {
+            issues(search: $search, state: $state, first: $first, after: $after, assigneeUsernames: $assigneeUsernames, authorUsername: $authorUsername, labelName: $labelName, sort: $sort) {
               pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
               nodes {
                 id
@@ -716,6 +799,21 @@ export class GitLabGraphQLClient {
           }
         }
       `;
+            if (fetchAll) {
+                return this.fetchAllPages(query, {
+                    projectPath,
+                    search: searchTerm,
+                    state: mapped,
+                    assigneeUsernames,
+                    authorUsername,
+                    labelName: labelNames,
+                    sort: sort || 'UPDATED_DESC'
+                }, 'project.issues', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
             return this.query(query, {
                 projectPath,
                 search: searchTerm,
@@ -724,7 +822,8 @@ export class GitLabGraphQLClient {
                 after,
                 assigneeUsernames,
                 authorUsername,
-                labelName: labelNames
+                labelName: labelNames,
+                sort: sort || 'UPDATED_DESC'
             }, userConfig);
         }
         else {
@@ -742,8 +841,8 @@ export class GitLabGraphQLClient {
             // We keep description for AI context but limit nested collections (assignees/labels)
             // Note: Global Issue type doesn't have 'project' field - only project-scoped queries do
             const query = gql `
-        query searchIssuesGlobal($search: String, $state: ${stateEnum}, $first: Int!, $after: String, $assigneeUsernames: [String!], $authorUsername: String, $labelName: [String!]) {
-          issues(search: $search, state: $state, first: $first, after: $after, assigneeUsernames: $assigneeUsernames, authorUsername: $authorUsername, labelName: $labelName) {
+        query searchIssuesGlobal($search: String, $state: ${stateEnum}, $first: Int!, $after: String, $assigneeUsernames: [String!], $authorUsername: String, $labelName: [String!], $sort: IssueSort) {
+          issues(search: $search, state: $state, first: $first, after: $after, assigneeUsernames: $assigneeUsernames, authorUsername: $authorUsername, labelName: $labelName, sort: $sort) {
             pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
             nodes {
               id
@@ -762,6 +861,20 @@ export class GitLabGraphQLClient {
       `;
             // Note: Global search returns streamlined fields (no assignees/labels/project) for performance.
             // For full details and project attribution, search within a specific project using projectPath.
+            if (fetchAll) {
+                return this.fetchAllPages(query, {
+                    search: searchTerm,
+                    state: mapped,
+                    assigneeUsernames,
+                    authorUsername,
+                    labelName: labelNames,
+                    sort: sort || 'UPDATED_DESC'
+                }, 'issues', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
             return this.query(query, {
                 search: searchTerm,
                 state: mapped,
@@ -769,17 +882,18 @@ export class GitLabGraphQLClient {
                 after,
                 assigneeUsernames,
                 authorUsername,
-                labelName: labelNames
+                labelName: labelNames,
+                sort: sort || 'UPDATED_DESC'
             }, userConfig);
         }
     }
-    async searchMergeRequests(searchTerm, projectPath, state, first = 20, after, userConfig) {
+    async searchMergeRequests(searchTerm, projectPath, state, first = 20, after, fetchAll = false, userConfig, sort) {
         const mappedState = state && state.toLowerCase() !== 'all' ? state.toUpperCase() : undefined;
         if (projectPath) {
             const query = gql `
-        query searchMergeRequestsProject($projectPath: ID!, $search: String, $state: MergeRequestState, $first: Int!, $after: String) {
+        query searchMergeRequestsProject($projectPath: ID!, $search: String, $state: MergeRequestState, $first: Int!, $after: String, $sort: MergeRequestSort) {
           project(fullPath: $projectPath) {
-            mergeRequests(search: $search, state: $state, first: $first, after: $after) {
+            mergeRequests(search: $search, state: $state, first: $first, after: $after, sort: $sort) {
               pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
               nodes {
                 id
@@ -798,12 +912,25 @@ export class GitLabGraphQLClient {
           }
         }
       `;
+            if (fetchAll) {
+                return this.fetchAllPages(query, {
+                    projectPath,
+                    search: searchTerm,
+                    state: mappedState,
+                    sort: sort || 'UPDATED_DESC'
+                }, 'project.mergeRequests', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
             return this.query(query, {
                 projectPath,
                 search: searchTerm,
                 state: mappedState,
-                first: Math.min(first, 50),
-                after
+                first: Math.min(first, this.config.maxPageSize),
+                after,
+                sort: sort || 'UPDATED_DESC'
             }, userConfig);
         }
         else {
@@ -851,9 +978,20 @@ export class GitLabGraphQLClient {
           }
         `;
                 try {
+                    if (fetchAll) {
+                        const connectionPath = `user.${fieldName}`;
+                        return this.fetchAllPages(query, {
+                            username,
+                            state: mappedState
+                        }, connectionPath, {
+                            maxItems: first,
+                            pageSize: this.config.maxPageSize,
+                            userConfig,
+                        });
+                    }
                     const result = await this.query(query, {
                         username,
-                        first: Math.min(first, 50),
+                        first: Math.min(first, this.config.maxPageSize),
                         after,
                         state: mappedState
                     }, userConfig);
@@ -997,10 +1135,16 @@ export class GitLabGraphQLClient {
             ref: ref || "HEAD"
         }, userConfig);
     }
-    async searchUsers(searchTerm, first = 20, userConfig) {
+    async searchUsers(searchTerm, first = 20, after, fetchAll = false, userConfig) {
         const query = gql `
-      query searchUsers($search: String!, $first: Int!) {
-        users(search: $search, first: $first) {
+      query searchUsers($search: String!, $first: Int!, $after: String) {
+        users(search: $search, first: $first, after: $after) {
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
           nodes {
             id
             username
@@ -1012,12 +1156,25 @@ export class GitLabGraphQLClient {
         }
       }
     `;
-        return this.query(query, { search: searchTerm, first: Math.min(first, 50) }, userConfig);
+        if (fetchAll) {
+            return this.fetchAllPages(query, { search: searchTerm }, 'users', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { search: searchTerm, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
     }
-    async searchGroups(searchTerm, first = 20, userConfig) {
+    async searchGroups(searchTerm, first = 20, after, fetchAll = false, userConfig) {
         const query = gql `
-      query searchGroups($search: String!, $first: Int!) {
-        groups(search: $search, first: $first) {
+      query searchGroups($search: String!, $first: Int!, $after: String) {
+        groups(search: $search, first: $first, after: $after) {
+          pageInfo {
+            hasNextPage
+            hasPreviousPage
+            startCursor
+            endCursor
+          }
           nodes {
             id
             name
@@ -1030,7 +1187,811 @@ export class GitLabGraphQLClient {
         }
       }
     `;
-        return this.query(query, { search: searchTerm, first: Math.min(first, 50) }, userConfig);
+        if (fetchAll) {
+            return this.fetchAllPages(query, { search: searchTerm }, 'groups', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { search: searchTerm, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+    }
+    // ── CI/CD Pipelines ──────────────────────────────────────────────────
+    async getMergeRequestPipelines(projectPath, iid, first = 20, after, fetchAll = false, userConfig) {
+        const query = gql `
+      query getMergeRequestPipelines($projectPath: ID!, $iid: String!, $first: Int!, $after: String) {
+        project(fullPath: $projectPath) {
+          mergeRequest(iid: $iid) {
+            pipelines(first: $first, after: $after) {
+              pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+              nodes {
+                id
+                iid
+                status
+                duration
+                createdAt
+                finishedAt
+                ref
+                sha
+                detailedStatus {
+                  text
+                  label
+                  icon
+                  group
+                  detailsPath
+                }
+                stages {
+                  nodes {
+                    name
+                    status
+                    detailedStatus {
+                      text
+                      label
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        if (fetchAll) {
+            return this.fetchAllPages(query, { projectPath, iid }, 'project.mergeRequest.pipelines', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { projectPath, iid, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+    }
+    async getPipelineJobs(projectPath, pipelineIid, first = 20, after, fetchAll = false, userConfig) {
+        const query = gql `
+      query getPipelineJobs($projectPath: ID!, $pipelineIid: ID!, $first: Int!, $after: String) {
+        project(fullPath: $projectPath) {
+          pipeline(iid: $pipelineIid) {
+            id
+            iid
+            status
+            jobs(first: $first, after: $after) {
+              pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+              nodes {
+                id
+                name
+                status
+                stage {
+                  name
+                }
+                duration
+                queuedDuration
+                createdAt
+                startedAt
+                finishedAt
+                retryable
+                cancelable
+                webPath
+                detailedStatus {
+                  text
+                  label
+                  icon
+                  group
+                  detailsPath
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        if (fetchAll) {
+            return this.fetchAllPages(query, { projectPath, pipelineIid }, 'project.pipeline.jobs', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { projectPath, pipelineIid, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+    }
+    async getPipelineId(projectPath, pipelineIid, userConfig) {
+        const query = gql `
+      query pipelineId($projectPath: ID!, $pipelineIid: ID!) {
+        project(fullPath: $projectPath) {
+          pipeline(iid: $pipelineIid) { id }
+        }
+      }
+    `;
+        const result = await this.query(query, { projectPath, pipelineIid }, userConfig);
+        const id = result?.project?.pipeline?.id;
+        if (!id)
+            throw new Error('Pipeline not found');
+        return id;
+    }
+    async managePipeline(projectPath, pipelineIid, action, userConfig) {
+        await this.introspectSchema(userConfig);
+        const mutationType = this.schema?.getMutationType();
+        const fields = mutationType ? mutationType.getFields() : {};
+        const pipelineGlobalId = await this.getPipelineId(projectPath, pipelineIid, userConfig);
+        if (action === 'retry') {
+            const fieldName = fields['pipelineRetry'] ? 'pipelineRetry' : null;
+            if (!fieldName) {
+                throw new Error('pipelineRetry mutation is not available on this GitLab instance');
+            }
+            const mutation = gql `
+        mutation retryPipeline($input: PipelineRetryInput!) {
+          pipelineRetry(input: $input) {
+            pipeline { id iid status }
+            errors
+          }
+        }
+      `;
+            const result = await this.query(mutation, { input: { id: pipelineGlobalId } }, userConfig, true);
+            const payload = result.pipelineRetry;
+            if (payload.errors && payload.errors.length > 0) {
+                throw new Error(`Failed to retry pipeline: ${payload.errors.join(', ')}`);
+            }
+            return payload;
+        }
+        else {
+            const fieldName = fields['pipelineCancel'] ? 'pipelineCancel' : null;
+            if (!fieldName) {
+                throw new Error('pipelineCancel mutation is not available on this GitLab instance');
+            }
+            const mutation = gql `
+        mutation cancelPipeline($input: PipelineCancelInput!) {
+          pipelineCancel(input: $input) {
+            errors
+          }
+        }
+      `;
+            const result = await this.query(mutation, { input: { id: pipelineGlobalId } }, userConfig, true);
+            const payload = result.pipelineCancel;
+            if (payload.errors && payload.errors.length > 0) {
+                throw new Error(`Failed to cancel pipeline: ${payload.errors.join(', ')}`);
+            }
+            return payload;
+        }
+    }
+    // ── MR Diffs & Commits ───────────────────────────────────────────────
+    async getMergeRequestDiffs(projectPath, iid, userConfig) {
+        const query = gql `
+      query getMergeRequestDiffs($projectPath: ID!, $iid: String!) {
+        project(fullPath: $projectPath) {
+          mergeRequest(iid: $iid) {
+            diffStatsSummary {
+              additions
+              deletions
+              fileCount
+            }
+            diffStats {
+              path
+              additions
+              deletions
+            }
+            diffRefs {
+              baseSha
+              headSha
+              startSha
+            }
+          }
+        }
+      }
+    `;
+        return this.query(query, { projectPath, iid }, userConfig);
+    }
+    async getMergeRequestCommits(projectPath, iid, first = 20, after, fetchAll = false, userConfig) {
+        const query = gql `
+      query getMergeRequestCommits($projectPath: ID!, $iid: String!, $first: Int!, $after: String) {
+        project(fullPath: $projectPath) {
+          mergeRequest(iid: $iid) {
+            commitCount
+            commitsWithoutMergeCommits(first: $first, after: $after) {
+              pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+              nodes {
+                sha
+                shortId
+                title
+                message
+                authorName
+                authoredDate
+                webUrl
+              }
+            }
+          }
+        }
+      }
+    `;
+        if (fetchAll) {
+            return this.fetchAllPages(query, { projectPath, iid }, 'project.mergeRequest.commitsWithoutMergeCommits', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, { projectPath, iid, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+    }
+    // ── Work Item Notes ──────────────────────────────────────────────────
+    async getNotes(projectPath, noteableType, iid, first = 20, after, fetchAll = false, userConfig) {
+        if (noteableType === 'issue') {
+            const query = gql `
+        query getIssueNotes($projectPath: ID!, $iid: String!, $first: Int!, $after: String) {
+          project(fullPath: $projectPath) {
+            issue(iid: $iid) {
+              notes(first: $first, after: $after) {
+                pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+                nodes {
+                  id
+                  body
+                  author { username name }
+                  createdAt
+                  updatedAt
+                  system
+                  internal
+                  url
+                }
+              }
+            }
+          }
+        }
+      `;
+            if (fetchAll) {
+                return this.fetchAllPages(query, { projectPath, iid }, 'project.issue.notes', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
+            return this.query(query, { projectPath, iid, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+        }
+        else {
+            const query = gql `
+        query getMergeRequestNotes($projectPath: ID!, $iid: String!, $first: Int!, $after: String) {
+          project(fullPath: $projectPath) {
+            mergeRequest(iid: $iid) {
+              notes(first: $first, after: $after) {
+                pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+                nodes {
+                  id
+                  body
+                  author { username name }
+                  createdAt
+                  updatedAt
+                  system
+                  internal
+                  url
+                  position {
+                    filePath
+                    newLine
+                    oldLine
+                  }
+                }
+              }
+            }
+          }
+        }
+      `;
+            if (fetchAll) {
+                return this.fetchAllPages(query, { projectPath, iid }, 'project.mergeRequest.notes', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
+            return this.query(query, { projectPath, iid, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+        }
+    }
+    async createNote(projectPath, noteableType, iid, body, internal = false, userConfig) {
+        await this.introspectSchema(userConfig);
+        const mutationType = this.schema?.getMutationType();
+        const fields = mutationType ? mutationType.getFields() : {};
+        const fieldName = fields['createNote'] ? 'createNote' : null;
+        if (!fieldName) {
+            throw new Error('createNote mutation is not available on this GitLab instance');
+        }
+        // Resolve the noteable IID to a global ID
+        const noteableId = noteableType === 'issue'
+            ? await this.getIssueId(projectPath, iid, userConfig)
+            : await this.getMergeRequestId(projectPath, iid, userConfig);
+        const mutation = gql `
+      mutation createNote($input: CreateNoteInput!) {
+        createNote(input: $input) {
+          note {
+            id
+            body
+            author { username name }
+            createdAt
+            url
+            internal
+          }
+          errors
+        }
+      }
+    `;
+        const input = {
+            noteableId,
+            body,
+        };
+        if (internal) {
+            input.internal = true;
+        }
+        const result = await this.query(mutation, { input }, userConfig, true);
+        return result.createNote;
+    }
+    // ── Milestones ─────────────────────────────────────────────────────
+    async listMilestones(fullPath, isProject, state, search, includeAncestors = false, first = 20, after, fetchAll = false, userConfig) {
+        const milestoneFields = `
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+      nodes {
+        id
+        iid
+        title
+        description
+        state
+        dueDate
+        startDate
+        expired
+        upcoming
+        webPath
+        stats {
+          totalIssuesCount
+          closedIssuesCount
+        }
+        createdAt
+        updatedAt
+      }
+    `;
+        if (isProject) {
+            const query = gql `
+        query listProjectMilestones($fullPath: ID!, $state: MilestoneStateEnum, $searchTitle: String, $includeAncestors: Boolean, $first: Int!, $after: String) {
+          project(fullPath: $fullPath) {
+            milestones(state: $state, searchTitle: $searchTitle, includeAncestors: $includeAncestors, first: $first, after: $after) {
+              ${milestoneFields}
+            }
+          }
+        }
+      `;
+            if (fetchAll) {
+                return this.fetchAllPages(query, {
+                    fullPath,
+                    state: state?.toLowerCase(),
+                    searchTitle: search,
+                    includeAncestors,
+                }, 'project.milestones', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
+            return this.query(query, {
+                fullPath,
+                state: state?.toLowerCase(),
+                searchTitle: search,
+                includeAncestors,
+                first: Math.min(first, this.config.maxPageSize),
+                after,
+            }, userConfig);
+        }
+        else {
+            const query = gql `
+        query listGroupMilestones($fullPath: ID!, $state: MilestoneStateEnum, $searchTitle: String, $includeAncestors: Boolean, $first: Int!, $after: String) {
+          group(fullPath: $fullPath) {
+            milestones(state: $state, searchTitle: $searchTitle, includeAncestors: $includeAncestors, first: $first, after: $after) {
+              ${milestoneFields}
+            }
+          }
+        }
+      `;
+            if (fetchAll) {
+                return this.fetchAllPages(query, {
+                    fullPath,
+                    state: state?.toLowerCase(),
+                    searchTitle: search,
+                    includeAncestors,
+                }, 'group.milestones', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
+            return this.query(query, {
+                fullPath,
+                state: state?.toLowerCase(),
+                searchTitle: search,
+                includeAncestors,
+                first: Math.min(first, this.config.maxPageSize),
+                after,
+            }, userConfig);
+        }
+    }
+    // ── Iterations ────────────────────────────────────────────────────
+    async listIterations(groupPath, state, first = 20, after, fetchAll = false, userConfig) {
+        const query = gql `
+      query listIterations($groupPath: ID!, $state: IterationState, $first: Int!, $after: String) {
+        group(fullPath: $groupPath) {
+          iterations(state: $state, first: $first, after: $after) {
+            pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+            nodes {
+              id
+              iid
+              title
+              description
+              state
+              startDate
+              dueDate
+              webUrl
+              scopedPath
+              iterationCadence {
+                id
+                title
+                active
+                durationInWeeks
+              }
+              createdAt
+              updatedAt
+            }
+          }
+        }
+      }
+    `;
+        if (fetchAll) {
+            return this.fetchAllPages(query, {
+                groupPath,
+                state: state?.toLowerCase(),
+            }, 'group.iterations', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, {
+            groupPath,
+            state: state?.toLowerCase(),
+            first: Math.min(first, this.config.maxPageSize),
+            after,
+        }, userConfig);
+    }
+    // ── Time Tracking ─────────────────────────────────────────────────
+    async getTimeTracking(projectPath, resourceType, iid, includeTimelogs = true, first = 20, after, userConfig) {
+        const timelogFields = includeTimelogs ? `
+      timelogs(first: $first, after: $after) {
+        pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+        nodes {
+          id
+          timeSpent
+          summary
+          spentAt
+          user {
+            username
+            name
+          }
+        }
+      }
+    ` : '';
+        if (resourceType === 'issue') {
+            const query = gql `
+        query getIssueTimeTracking($projectPath: ID!, $iid: String!, $first: Int!, $after: String) {
+          project(fullPath: $projectPath) {
+            issue(iid: $iid) {
+              iid
+              title
+              webUrl
+              timeEstimate
+              totalTimeSpent
+              humanTimeEstimate
+              humanTotalTimeSpent
+              ${timelogFields}
+            }
+          }
+        }
+      `;
+            return this.query(query, { projectPath, iid, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+        }
+        else {
+            const query = gql `
+        query getMergeRequestTimeTracking($projectPath: ID!, $iid: String!, $first: Int!, $after: String) {
+          project(fullPath: $projectPath) {
+            mergeRequest(iid: $iid) {
+              iid
+              title
+              webUrl
+              timeEstimate
+              totalTimeSpent
+              humanTimeEstimate
+              humanTotalTimeSpent
+              ${timelogFields}
+            }
+          }
+        }
+      `;
+            return this.query(query, { projectPath, iid, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+        }
+    }
+    // ── MR Reviewers & Approvals ──────────────────────────────────────
+    async getMergeRequestReviewers(projectPath, iid, userConfig) {
+        const query = gql `
+      query getMergeRequestReviewers($projectPath: ID!, $iid: String!) {
+        project(fullPath: $projectPath) {
+          mergeRequest(iid: $iid) {
+            iid
+            title
+            webUrl
+            state
+            approved
+            approvalsRequired
+            approvalsLeft
+            approvedBy {
+              nodes {
+                username
+                name
+                avatarUrl
+                webUrl
+              }
+            }
+            reviewers {
+              nodes {
+                username
+                name
+                avatarUrl
+                webUrl
+                mergeRequestInteraction {
+                  reviewState
+                  approved
+                  reviewed
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        return this.query(query, { projectPath, iid }, userConfig);
+    }
+    // ── Project Statistics ────────────────────────────────────────────
+    async getProjectStatistics(projectPath, userConfig) {
+        const query = gql `
+      query getProjectStatistics($projectPath: ID!) {
+        project(fullPath: $projectPath) {
+          id
+          name
+          fullPath
+          webUrl
+          starCount
+          forksCount
+          openIssuesCount
+          statistics {
+            repositorySize
+            lfsObjectsSize
+            buildArtifactsSize
+            packagesSize
+            wikiSize
+            snippetsSize
+            uploadsSize
+            containerRegistrySize
+            commitCount
+          }
+          openMergeRequests: mergeRequests(state: opened) {
+            count
+          }
+          lastPipeline: pipelines(first: 1) {
+            nodes {
+              id
+              iid
+              status
+              createdAt
+              finishedAt
+              ref
+              detailedStatus {
+                text
+                label
+              }
+            }
+          }
+          releaseCount: releases {
+            count
+          }
+          languages {
+            name
+            share
+            color
+          }
+        }
+      }
+    `;
+        return this.query(query, { projectPath }, userConfig);
+    }
+    // ── Group Members ─────────────────────────────────────────────────
+    async listGroupMembers(groupPath, search, first = 20, after, fetchAll = false, userConfig) {
+        const query = gql `
+      query listGroupMembers($groupPath: ID!, $search: String, $first: Int!, $after: String) {
+        group(fullPath: $groupPath) {
+          groupMembers(search: $search, first: $first, after: $after) {
+            pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+            nodes {
+              id
+              accessLevel {
+                stringValue
+                integerValue
+              }
+              createdAt
+              expiresAt
+              user {
+                username
+                name
+                avatarUrl
+                webUrl
+                state
+              }
+            }
+          }
+        }
+      }
+    `;
+        if (fetchAll) {
+            return this.fetchAllPages(query, {
+                groupPath,
+                search: search || undefined,
+            }, 'group.groupMembers', {
+                maxItems: first,
+                pageSize: this.config.maxPageSize,
+                userConfig,
+            });
+        }
+        return this.query(query, {
+            groupPath,
+            search: search || undefined,
+            first: Math.min(first, this.config.maxPageSize),
+            after,
+        }, userConfig);
+    }
+    // ── Label Search ─────────────────────────────────────────────────────
+    async searchLabels(fullPath, isProject, search, first = 20, after, fetchAll = false, userConfig) {
+        if (isProject) {
+            const query = gql `
+        query searchProjectLabels($fullPath: ID!, $search: String, $first: Int!, $after: String) {
+          project(fullPath: $fullPath) {
+            labels(searchTerm: $search, first: $first, after: $after) {
+              pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+              nodes {
+                id
+                title
+                description
+                color
+                textColor
+                createdAt
+                updatedAt
+              }
+            }
+          }
+        }
+      `;
+            if (fetchAll) {
+                return this.fetchAllPages(query, { fullPath, search }, 'project.labels', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
+            return this.query(query, { fullPath, search, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+        }
+        else {
+            const query = gql `
+        query searchGroupLabels($fullPath: ID!, $search: String, $first: Int!, $after: String) {
+          group(fullPath: $fullPath) {
+            labels(searchTerm: $search, first: $first, after: $after) {
+              pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+              nodes {
+                id
+                title
+                description
+                color
+                textColor
+                createdAt
+                updatedAt
+              }
+            }
+          }
+        }
+      `;
+            if (fetchAll) {
+                return this.fetchAllPages(query, { fullPath, search }, 'group.labels', {
+                    maxItems: first,
+                    pageSize: this.config.maxPageSize,
+                    userConfig,
+                });
+            }
+            return this.query(query, { fullPath, search, first: Math.min(first, this.config.maxPageSize), after }, userConfig);
+        }
+    }
+    /**
+     * Resolve the GitLab base URL and access token for a REST call, honoring
+     * per-request user credentials and falling back to the shared token.
+     */
+    resolveRestAuth(userConfig, requiresWrite = false) {
+        if (userConfig) {
+            return {
+                baseUrl: userConfig.gitlabUrl || this.config.gitlabUrl,
+                token: userConfig.accessToken,
+            };
+        }
+        if (requiresWrite) {
+            throw new Error('Write operations require user authentication. Please provide your GitLab credentials.');
+        }
+        if (this.config.sharedAccessToken && this.config.authMode !== 'per-user') {
+            return { baseUrl: this.config.gitlabUrl, token: this.config.sharedAccessToken };
+        }
+        throw new Error('This operation requires user authentication. Please provide your GitLab credentials.');
+    }
+    /**
+     * Perform a GitLab REST API v4 request. Used for endpoints not exposed via GraphQL
+     * (e.g., broadcast messages).
+     */
+    async restRequest(method, path, options = {}) {
+        const { baseUrl, token } = this.resolveRestAuth(options.userConfig, options.requiresWrite);
+        const url = new URL(`${baseUrl.replace(/\/$/, '')}/api/v4${path}`);
+        if (options.query) {
+            for (const [k, v] of Object.entries(options.query)) {
+                if (v !== undefined && v !== null)
+                    url.searchParams.set(k, String(v));
+            }
+        }
+        const timeoutMs = this.config.defaultTimeout || 30000;
+        return this.executeWithRetry(async () => {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetch(url.toString(), {
+                    method,
+                    headers: {
+                        Authorization: `Bearer ${token}`,
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json',
+                    },
+                    body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const statusCode = response.status;
+                    let message = `${response.statusText}`;
+                    try {
+                        const errBody = await response.json();
+                        message = errBody?.message || errBody?.error || JSON.stringify(errBody);
+                    }
+                    catch {
+                        // non-JSON body
+                    }
+                    const retryable = RETRY_CONFIG.retryableStatusCodes.includes(statusCode);
+                    throw new GitLabAPIError(`GitLab REST ${method} ${path} failed (${statusCode}): ${message}`, {
+                        code: statusCode === 401 ? 'AUTH_FAILED' : statusCode === 403 ? 'FORBIDDEN' : 'HTTP_ERROR',
+                        statusCode,
+                        isRetryable: retryable,
+                    });
+                }
+                if (response.status === 204)
+                    return undefined;
+                const text = await response.text();
+                return (text ? JSON.parse(text) : undefined);
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }, `REST ${method} ${path}`);
+    }
+    async listBroadcastMessages(page = 1, perPage = 20, userConfig) {
+        return this.restRequest('GET', '/broadcast_messages', {
+            query: { page, per_page: Math.min(perPage, this.config.maxPageSize) },
+            userConfig,
+        });
+    }
+    async getBroadcastMessage(id, userConfig) {
+        return this.restRequest('GET', `/broadcast_messages/${id}`, { userConfig });
+    }
+    async createBroadcastMessage(input, userConfig) {
+        return this.restRequest('POST', '/broadcast_messages', { body: input, userConfig, requiresWrite: true });
+    }
+    async updateBroadcastMessage(id, input, userConfig) {
+        return this.restRequest('PUT', `/broadcast_messages/${id}`, { body: input, userConfig, requiresWrite: true });
+    }
+    async deleteBroadcastMessage(id, userConfig) {
+        return this.restRequest('DELETE', `/broadcast_messages/${id}`, { userConfig, requiresWrite: true });
     }
 }
 //# sourceMappingURL=gitlab-client.js.map