@forge-glance/sdk 0.1.0 → 0.2.0

package/src/GitLabProvider.ts

@@ -1,14 +1,19 @@
-import type { GitProvider } from "./GitProvider.ts";
+import type { GitProvider } from './GitProvider.ts';
 import type {
+  BranchProtectionRule,
+  CreatePullRequestInput,
   DiffStats,
+  MergePullRequestInput,
   MRDetail,
   Pipeline,
   PipelineJob,
+  ProviderCapabilities,
   PullRequest,
-  UserRef,
-} from "./types.ts";
-import { type ForgeLogger, noopLogger } from "./logger.ts";
-import { MRDetailFetcher } from "./MRDetailFetcher.ts";
+  UpdatePullRequestInput,
+  UserRef
+} from './types.ts';
+import { type ForgeLogger, noopLogger } from './logger.ts';
+import { MRDetailFetcher } from './MRDetailFetcher.ts';
 
 // ---------------------------------------------------------------------------
 // Repository ID helpers
@@ -20,8 +25,8 @@ import { MRDetailFetcher } from "./MRDetailFetcher.ts";
  * e.g. "gitlab:42" → 42
  */
 export function parseGitLabRepoId(repositoryId: string): number {
-  const parts = repositoryId.split(":");
-  return parseInt(parts.at(-1) ?? "0", 10);
+  const parts = repositoryId.split(':');
+  return parseInt(parts.at(-1) ?? '0', 10);
 }
 
 // ---------------------------------------------------------------------------
@@ -178,8 +183,8 @@ interface AssignedResponse {
 
 /** Extract numeric ID from a GQL global ID like "gid://gitlab/MergeRequest/12345". */
 function numericId(gid: string): number {
-  const parts = gid.split("/");
-  return parseInt(parts[parts.length - 1] ?? "0", 10);
+  const parts = gid.split('/');
+  return parseInt(parts[parts.length - 1] ?? '0', 10);
 }
 
 /** Build a scoped domain ID from a GitLab numeric integer. */
@@ -192,29 +197,28 @@ function toUserRef(u: GQLUser): UserRef {
     id: `gitlab:user:${numericId(u.id)}`,
     username: u.username,
     name: u.name,
-    avatarUrl: u.avatarUrl,
+    avatarUrl: u.avatarUrl
   };
 }
 
-
 function toPipeline(p: GQLPipeline, baseURL: string): Pipeline {
-  const allJobs: PipelineJob[] = p.stages.nodes.flatMap((stage) =>
-    stage.jobs.nodes.map((job) => ({
+  const allJobs: PipelineJob[] = p.stages.nodes.flatMap(stage =>
+    stage.jobs.nodes.map(job => ({
       id: `gitlab:job:${numericId(job.id)}`,
       name: job.name,
       stage: job.stage.name,
       status: job.status,
       allowFailure: job.allowFailure,
-      webUrl: job.webPath ? `${baseURL}${job.webPath}` : null,
-    })),
+      webUrl: job.webPath ? `${baseURL}${job.webPath}` : null
+    }))
   );
 
   return {
-    id: domainId("pipeline", numericId(p.id)),
+    id: domainId('pipeline', numericId(p.id)),
     status: normalizePipelineStatus(p),
     createdAt: p.createdAt,
     webUrl: p.path ? `${baseURL}${p.path}` : null,
-    jobs: allJobs,
+    jobs: allJobs
   };
 }
 
@@ -224,12 +228,12 @@ function toPipeline(p: GQLPipeline, baseURL: string): Pipeline {
  * if any allow-failure job failed but overall status is success → "success_with_warnings"
  */
 function normalizePipelineStatus(p: GQLPipeline): string {
-  const allJobs = p.stages.nodes.flatMap((s) => s.jobs.nodes);
+  const allJobs = p.stages.nodes.flatMap(s => s.jobs.nodes);
   const hasAllowFailFailed = allJobs.some(
-    (j) => j.allowFailure && j.status === "failed",
+    j => j.allowFailure && j.status === 'failed'
   );
-  if (p.status === "success" && hasAllowFailFailed) {
-    return "success_with_warnings";
+  if (p.status === 'success' && hasAllowFailFailed) {
+    return 'success_with_warnings';
   }
   return p.status;
 }
@@ -243,7 +247,7 @@ function toMR(gql: GQLMR, role: string, baseURL: string): PullRequest {
     ? {
         additions: gql.diffStatsSummary.additions,
         deletions: gql.diffStatsSummary.deletions,
-        filesChanged: gql.diffStatsSummary.fileCount,
+        filesChanged: gql.diffStatsSummary.fileCount
       }
     : null;
 
@@ -255,7 +259,7 @@ function toMR(gql: GQLMR, role: string, baseURL: string): PullRequest {
     description: gql.description ?? null,
     state: gql.state,
     draft: gql.draft,
-    conflicts: gql.conflicts || gql.detailedMergeStatus === "conflict",
+    conflicts: gql.conflicts || gql.detailedMergeStatus === 'conflict',
     webUrl: gql.webUrl,
     sourceBranch: gql.sourceBranch,
     targetBranch: gql.targetBranch,
@@ -272,7 +276,7 @@ function toMR(gql: GQLMR, role: string, baseURL: string): PullRequest {
     approved: gql.approved ?? false,
     approvedBy: gql.approvedBy.nodes.map(toUserRef),
     diffStats,
-    detailedMergeStatus: gql.detailedMergeStatus ?? null,
+    detailedMergeStatus: gql.detailedMergeStatus ?? null
   };
 }
 
@@ -300,29 +304,50 @@ interface MRDetailResponse {
 // ---------------------------------------------------------------------------
 
 export class GitLabProvider implements GitProvider {
-  readonly providerName = "gitlab" as const;
+  readonly providerName = 'gitlab' as const;
   readonly baseURL: string;
   private readonly token: string;
   private readonly log: ForgeLogger;
   private readonly mrDetailFetcher: MRDetailFetcher;
 
-  constructor(baseURL: string, token: string, options: { logger?: ForgeLogger } = {}) {
+  constructor(
+    baseURL: string,
+    token: string,
+    options: { logger?: ForgeLogger } = {}
+  ) {
     // Strip trailing slash for consistent URL building
-    this.baseURL = baseURL.replace(/\/$/, "");
+    this.baseURL = baseURL.replace(/\/$/, '');
     this.token = token;
     this.log = options.logger ?? noopLogger;
-    this.mrDetailFetcher = new MRDetailFetcher(this.baseURL, token, { logger: this.log });
+    this.mrDetailFetcher = new MRDetailFetcher(this.baseURL, token, {
+      logger: this.log
+    });
   }
 
+  // ── Capabilities ──────────────────────────────────────────────────────
+
+  readonly capabilities: ProviderCapabilities = {
+    canMerge: true,
+    canApprove: true,
+    canUnapprove: true,
+    canRebase: true,
+    canAutoMerge: true,
+    canResolveDiscussions: true,
+    canRetryPipeline: true,
+    canRequestReReview: true
+  };
+
   // MARK: - GitProvider
 
   async validateToken(): Promise<UserRef> {
     const url = `${this.baseURL}/api/v4/user`;
     const res = await fetch(url, {
-      headers: { "PRIVATE-TOKEN": this.token },
+      headers: { 'PRIVATE-TOKEN': this.token }
     });
     if (!res.ok) {
-      throw new Error(`Token validation failed: ${res.status} ${res.statusText}`);
+      throw new Error(
+        `Token validation failed: ${res.status} ${res.statusText}`
+      );
     }
     const user = (await res.json()) as {
       id: number;
@@ -334,7 +359,7 @@ export class GitLabProvider implements GitProvider {
       id: `gitlab:user:${user.id}`,
       username: user.username,
       name: user.name,
-      avatarUrl: user.avatar_url,
+      avatarUrl: user.avatar_url
     };
   }
 
@@ -349,17 +374,17 @@ export class GitLabProvider implements GitProvider {
   async fetchSingleMR(
     projectPath: string,
     mrIid: number,
-    currentUserNumericId: number | null,
+    currentUserNumericId: number | null
   ): Promise<PullRequest | null> {
     let resp: MRDetailResponse;
     try {
       resp = await this.runQuery<MRDetailResponse>(MR_DETAIL_QUERY, {
         projectPath,
-        iid: String(mrIid),
+        iid: String(mrIid)
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      this.log.warn("fetchSingleMR failed", { projectPath, mrIid, message });
+      this.log.warn('fetchSingleMR failed', { projectPath, mrIid, message });
       return null;
     }
 
@@ -370,13 +395,15 @@ export class GitLabProvider implements GitProvider {
     const roles: string[] = [];
     if (currentUserNumericId !== null) {
       const userGqlId = `gid://gitlab/User/${currentUserNumericId}`;
-      if (gql.author.id === userGqlId) roles.push("author");
-      if (gql.assignees.nodes.some((u) => u.id === userGqlId)) roles.push("assignee");
-      if (gql.reviewers.nodes.some((u) => u.id === userGqlId)) roles.push("reviewer");
+      if (gql.author.id === userGqlId) roles.push('author');
+      if (gql.assignees.nodes.some(u => u.id === userGqlId))
+        roles.push('assignee');
+      if (gql.reviewers.nodes.some(u => u.id === userGqlId))
+        roles.push('reviewer');
     }
 
     // Use "author" as the primary role for toMR, then overwrite with full computed roles.
-    const pr = toMR(gql, roles[0] ?? "author", this.baseURL);
+    const pr = toMR(gql, roles[0] ?? 'author', this.baseURL);
     pr.roles = roles.length > 0 ? roles : pr.roles;
     return pr;
   }
@@ -385,7 +412,7 @@ export class GitLabProvider implements GitProvider {
     const [authored, reviewing, assigned] = await Promise.all([
       this.runQuery<AuthoredResponse>(AUTHORED_QUERY),
       this.runQuery<ReviewingResponse>(REVIEWING_QUERY),
-      this.runQuery<AssignedResponse>(ASSIGNED_QUERY),
+      this.runQuery<AssignedResponse>(ASSIGNED_QUERY)
     ]);
 
     // Merge all three sets, deduplicating by MR global ID.
@@ -405,51 +432,487 @@ export class GitLabProvider implements GitProvider {
       }
     };
 
-    addAll(authored.currentUser.authoredMergeRequests.nodes, "author");
-    addAll(reviewing.currentUser.reviewRequestedMergeRequests.nodes, "reviewer");
-    addAll(assigned.currentUser.assignedMergeRequests.nodes, "assignee");
+    addAll(authored.currentUser.authoredMergeRequests.nodes, 'author');
+    addAll(
+      reviewing.currentUser.reviewRequestedMergeRequests.nodes,
+      'reviewer'
+    );
+    addAll(assigned.currentUser.assignedMergeRequests.nodes, 'assignee');
 
     const prs = [...byId.values()];
-    this.log.debug("fetchPullRequests", { count: prs.length });
+    this.log.debug('fetchPullRequests', { count: prs.length });
     return prs;
   }
 
-  async fetchMRDiscussions(repositoryId: string, mrIid: number): Promise<MRDetail> {
+  async fetchMRDiscussions(
+    repositoryId: string,
+    mrIid: number
+  ): Promise<MRDetail> {
     const projectId = parseGitLabRepoId(repositoryId);
     return this.mrDetailFetcher.fetchDetail(projectId, mrIid);
   }
 
-  async restRequest(method: string, path: string, body?: unknown): Promise<Response> {
+  async fetchBranchProtectionRules(
+    projectPath: string
+  ): Promise<BranchProtectionRule[]> {
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/protected_branches?per_page=100`,
+      { headers: { 'PRIVATE-TOKEN': this.token } }
+    );
+    if (!res.ok) {
+      throw new Error(
+        `fetchBranchProtectionRules failed: ${res.status} ${await res.text()}`
+      );
+    }
+    const branches = (await res.json()) as Array<{
+      name: string;
+      allow_force_push: boolean;
+      push_access_levels: Array<{ access_level: number }>;
+      merge_access_levels: Array<{ access_level: number }>;
+      code_owner_approval_required?: boolean;
+    }>;
+    return branches.map(b => ({
+      pattern: b.name,
+      allowForcePush: b.allow_force_push,
+      allowDeletion: false,
+      requiredApprovals: 0,
+      requireStatusChecks: false,
+      raw: b as unknown as Record<string, unknown>
+    }));
+  }
+
+  async deleteBranch(projectPath: string, branch: string): Promise<void> {
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/repository/branches/${encodeURIComponent(branch)}`,
+      { method: 'DELETE', headers: { 'PRIVATE-TOKEN': this.token } }
+    );
+    if (!res.ok) {
+      throw new Error(`deleteBranch failed: ${res.status} ${await res.text()}`);
+    }
+  }
+
+  async fetchPullRequestByBranch(
+    projectPath: string,
+    sourceBranch: string
+  ): Promise<PullRequest | null> {
+    const encoded = encodeURIComponent(projectPath);
+    const url = `${this.baseURL}/api/v4/projects/${encoded}/merge_requests?source_branch=${encodeURIComponent(sourceBranch)}&state=opened&per_page=1`;
+    const res = await fetch(url, {
+      headers: { 'PRIVATE-TOKEN': this.token }
+    });
+    if (!res.ok) {
+      this.log.warn('fetchPullRequestByBranch failed', {
+        projectPath,
+        sourceBranch,
+        status: res.status
+      });
+      return null;
+    }
+    const mrs = (await res.json()) as Array<{ iid: number }>;
+    if (!mrs[0]) return null;
+    return this.fetchSingleMR(projectPath, mrs[0].iid, null);
+  }
+
+  async createPullRequest(input: CreatePullRequestInput): Promise<PullRequest> {
+    const encoded = encodeURIComponent(input.projectPath);
+    const body: Record<string, unknown> = {
+      source_branch: input.sourceBranch,
+      target_branch: input.targetBranch,
+      title: input.title
+    };
+    if (input.description != null) body.description = input.description;
+    if (input.draft != null) body.draft = input.draft;
+    if (input.labels?.length) body.labels = input.labels.join(',');
+    if (input.assignees?.length) body.assignee_ids = input.assignees;
+    if (input.reviewers?.length) body.reviewer_ids = input.reviewers;
+
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests`,
+      {
+        method: 'POST',
+        headers: {
+          'PRIVATE-TOKEN': this.token,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`createPullRequest failed: ${res.status} ${text}`);
+    }
+    const created = (await res.json()) as { iid: number };
+    return this.fetchSingleMRWithRetry(
+      input.projectPath,
+      created.iid,
+      'Created MR but failed to fetch it back'
+    );
+  }
+
+  async updatePullRequest(
+    projectPath: string,
+    mrIid: number,
+    input: UpdatePullRequestInput
+  ): Promise<PullRequest> {
+    const encoded = encodeURIComponent(projectPath);
+    const body: Record<string, unknown> = {};
+    if (input.title != null) body.title = input.title;
+    if (input.description != null) body.description = input.description;
+    if (input.draft != null) body.draft = input.draft;
+    if (input.targetBranch != null) body.target_branch = input.targetBranch;
+    if (input.labels) body.labels = input.labels.join(',');
+    if (input.assignees) body.assignee_ids = input.assignees;
+    if (input.reviewers) body.reviewer_ids = input.reviewers;
+    if (input.stateEvent) body.state_event = input.stateEvent;
+
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}`,
+      {
+        method: 'PUT',
+        headers: {
+          'PRIVATE-TOKEN': this.token,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`updatePullRequest failed: ${res.status} ${text}`);
+    }
+    return this.fetchSingleMRWithRetry(
+      projectPath,
+      mrIid,
+      'Updated MR but failed to fetch it back'
+    );
+  }
+
+  async restRequest(
+    method: string,
+    path: string,
+    body?: unknown
+  ): Promise<Response> {
     const url = `${this.baseURL}${path}`;
     const headers: Record<string, string> = {
-      "PRIVATE-TOKEN": this.token,
+      'PRIVATE-TOKEN': this.token
     };
     if (body !== undefined) {
-      headers["Content-Type"] = "application/json";
+      headers['Content-Type'] = 'application/json';
     }
     return fetch(url, {
       method,
       headers,
-      body: body !== undefined ? JSON.stringify(body) : undefined,
+      body: body !== undefined ? JSON.stringify(body) : undefined
     });
   }
 
+  // ── MR lifecycle mutations ──────────────────────────────────────────────
+
+  async mergePullRequest(
+    projectPath: string,
+    mrIid: number,
+    input?: MergePullRequestInput
+  ): Promise<PullRequest> {
+    const encoded = encodeURIComponent(projectPath);
+    const body: Record<string, unknown> = {};
+    if (input?.commitMessage != null)
+      body.merge_commit_message = input.commitMessage;
+    if (input?.squashCommitMessage != null)
+      body.squash_commit_message = input.squashCommitMessage;
+    if (input?.squash != null) body.squash = input.squash;
+    if (input?.shouldRemoveSourceBranch != null)
+      body.should_remove_source_branch = input.shouldRemoveSourceBranch;
+    if (input?.sha != null) body.sha = input.sha;
+    // mergeMethod: GitLab uses the project's configured merge method by default.
+    // The merge REST API doesn't accept a merge_method param — it honours the project setting.
+    // If the caller passes mergeMethod: "squash", we set squash = true as a hint.
+    if (input?.mergeMethod === 'squash' && input?.squash == null)
+      body.squash = true;
+
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}/merge`,
+      {
+        method: 'PUT',
+        headers: {
+          'PRIVATE-TOKEN': this.token,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`mergePullRequest failed: ${res.status} ${text}`);
+    }
+    return this.fetchSingleMRWithRetry(
+      projectPath,
+      mrIid,
+      'Merged MR but failed to fetch it back'
+    );
+  }
+
+  async approvePullRequest(projectPath: string, mrIid: number): Promise<void> {
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}/approve`,
+      {
+        method: 'POST',
+        headers: { 'PRIVATE-TOKEN': this.token }
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `approvePullRequest failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
+  async unapprovePullRequest(
+    projectPath: string,
+    mrIid: number
+  ): Promise<void> {
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}/unapprove`,
+      {
+        method: 'POST',
+        headers: { 'PRIVATE-TOKEN': this.token }
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `unapprovePullRequest failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
+  async rebasePullRequest(projectPath: string, mrIid: number): Promise<void> {
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}/rebase`,
+      {
+        method: 'PUT',
+        headers: { 'PRIVATE-TOKEN': this.token }
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `rebasePullRequest failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
+  async setAutoMerge(projectPath: string, mrIid: number): Promise<void> {
+    // REST: PUT merge with merge_when_pipeline_succeeds = true
+    // This tells GitLab to merge automatically once the head pipeline succeeds.
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}/merge`,
+      {
+        method: 'PUT',
+        headers: {
+          'PRIVATE-TOKEN': this.token,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ merge_when_pipeline_succeeds: true })
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `setAutoMerge failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
+  async cancelAutoMerge(projectPath: string, mrIid: number): Promise<void> {
+    // REST: POST cancel_merge_when_pipeline_succeeds
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}/cancel_merge_when_pipeline_succeeds`,
+      {
+        method: 'POST',
+        headers: { 'PRIVATE-TOKEN': this.token }
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `cancelAutoMerge failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
+  // ── Discussion mutations ────────────────────────────────────────────────
+
+  async resolveDiscussion(
+    projectPath: string,
+    mrIid: number,
+    discussionId: string
+  ): Promise<void> {
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}/discussions/${discussionId}`,
+      {
+        method: 'PUT',
+        headers: {
+          'PRIVATE-TOKEN': this.token,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ resolved: true })
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `resolveDiscussion failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
+  async unresolveDiscussion(
+    projectPath: string,
+    mrIid: number,
+    discussionId: string
+  ): Promise<void> {
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}/discussions/${discussionId}`,
+      {
+        method: 'PUT',
+        headers: {
+          'PRIVATE-TOKEN': this.token,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ resolved: false })
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `unresolveDiscussion failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
+  // ── Pipeline mutations ──────────────────────────────────────────────────
+
+  async retryPipeline(projectPath: string, pipelineId: number): Promise<void> {
+    const encoded = encodeURIComponent(projectPath);
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/pipelines/${pipelineId}/retry`,
+      {
+        method: 'POST',
+        headers: { 'PRIVATE-TOKEN': this.token }
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `retryPipeline failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
+  // ── Review mutations ────────────────────────────────────────────────────
+
+  async requestReReview(
+    projectPath: string,
+    mrIid: number,
+    _reviewerUsernames?: string[]
+  ): Promise<void> {
+    // GitLab does not have a dedicated "re-request review" endpoint.
+    // The approach: fetch the current MR to get reviewer IDs, then
+    // re-assign them via PUT to trigger review-requested notifications.
+    const encoded = encodeURIComponent(projectPath);
+
+    // Fetch current MR to get existing reviewer IDs
+    const mrRes = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}`,
+      { headers: { 'PRIVATE-TOKEN': this.token } }
+    );
+    if (!mrRes.ok) {
+      const text = await mrRes.text().catch(() => '');
+      throw new Error(
+        `requestReReview: failed to fetch MR: ${mrRes.status}${text ? ` — ${text}` : ''}`
+      );
+    }
+
+    const mr = (await mrRes.json()) as {
+      reviewers?: Array<{ id: number }>;
+    };
+    const reviewerIds = mr.reviewers?.map(r => r.id) ?? [];
+    if (reviewerIds.length === 0) {
+      // No reviewers to re-request
+      return;
+    }
+
+    // Re-assign the same reviewers to trigger notifications
+    const res = await fetch(
+      `${this.baseURL}/api/v4/projects/${encoded}/merge_requests/${mrIid}`,
+      {
+        method: 'PUT',
+        headers: {
+          'PRIVATE-TOKEN': this.token,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ reviewer_ids: reviewerIds })
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `requestReReview failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
   // MARK: - Private
 
-  private async runQuery<T>(query: string, variables?: Record<string, unknown>): Promise<T> {
+  /**
+   * Retry `fetchSingleMR` with exponential backoff to handle REST→GraphQL
+   * eventual consistency. GitLab's GraphQL may not immediately reflect
+   * changes made via REST. 3 attempts: 0ms, 300ms, 600ms delay.
+   */
+  private async fetchSingleMRWithRetry(
+    projectPath: string,
+    mrIid: number,
+    errorMessage: string
+  ): Promise<PullRequest> {
+    for (let attempt = 0; attempt < 3; attempt++) {
+      if (attempt > 0) {
+        await new Promise(r => setTimeout(r, attempt * 300));
+      }
+      const pr = await this.fetchSingleMR(projectPath, mrIid, null);
+      if (pr) return pr;
+    }
+    throw new Error(errorMessage);
+  }
+
+  private async runQuery<T>(
+    query: string,
+    variables?: Record<string, unknown>
+  ): Promise<T> {
     const url = `${this.baseURL}/api/graphql`;
     const body = JSON.stringify({ query, variables: variables ?? {} });
     const res = await fetch(url, {
-      method: "POST",
+      method: 'POST',
       headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.token}`
       },
-      body,
+      body
     });
 
     if (!res.ok) {
-      throw new Error(`GraphQL request failed: ${res.status} ${res.statusText}`);
+      throw new Error(
+        `GraphQL request failed: ${res.status} ${res.statusText}`
+      );
     }
 
     const envelope = (await res.json()) as {
@@ -458,12 +921,12 @@ export class GitLabProvider implements GitProvider {
     };
 
     if (envelope.errors?.length) {
-      const msg = envelope.errors.map((e) => e.message).join("; ");
+      const msg = envelope.errors.map(e => e.message).join('; ');
       throw new Error(`GraphQL errors: ${msg}`);
     }
 
     if (!envelope.data) {
-      throw new Error("GraphQL response missing data");
+      throw new Error('GraphQL response missing data');
     }
 
     return envelope.data;