@forge-glance/sdk 0.1.0 → 0.2.0

package/src/GitHubProvider.ts

@@ -12,20 +12,25 @@
  * provides the instance URL and we append "/api/v3".
  */
 
-import type { GitProvider } from "./GitProvider.ts";
+import type { GitProvider } from './GitProvider.ts';
 import type {
+  BranchProtectionRule,
+  CreatePullRequestInput,
   DiffStats,
   Discussion,
+  MergePullRequestInput,
   MRDetail,
   Note,
   NoteAuthor,
   NotePosition,
   Pipeline,
   PipelineJob,
+  ProviderCapabilities,
   PullRequest,
-  UserRef,
-} from "./types.ts";
-import { type ForgeLogger, noopLogger } from "./logger.ts";
+  UpdatePullRequestInput,
+  UserRef
+} from './types.ts';
+import { type ForgeLogger, noopLogger } from './logger.ts';
 
 // ---------------------------------------------------------------------------
 // GitHub REST API response shapes (only fields we consume)
@@ -119,7 +124,7 @@ function toUserRef(u: GHUser): UserRef {
     id: `github:user:${u.id}`,
     username: u.login,
     name: u.name ?? u.login,
-    avatarUrl: u.avatar_url,
+    avatarUrl: u.avatar_url
   };
 }
 
@@ -128,9 +133,9 @@ function toUserRef(u: GHUser): UserRef {
  * GitHub only has "open" and "closed"; we check `merged_at` to distinguish merges.
  */
 function normalizePRState(pr: GHPullRequest): string {
-  if (pr.merged_at) return "merged";
-  if (pr.state === "open") return "opened";
-  return "closed";
+  if (pr.merged_at) return 'merged';
+  if (pr.state === 'open') return 'opened';
+  return 'closed';
 }
 
 /**
@@ -139,32 +144,32 @@ function normalizePRState(pr: GHPullRequest): string {
  */
 function toPipeline(
   checkRuns: GHCheckRun[],
-  prHtmlUrl: string,
+  prHtmlUrl: string
 ): Pipeline | null {
   if (checkRuns.length === 0) return null;
 
-  const jobs: PipelineJob[] = checkRuns.map((cr) => ({
+  const jobs: PipelineJob[] = checkRuns.map(cr => ({
     id: `github:check:${cr.id}`,
     name: cr.name,
-    stage: "checks", // GitHub doesn't have stages; use a flat stage name
+    stage: 'checks', // GitHub doesn't have stages; use a flat stage name
     status: normalizeCheckStatus(cr),
     allowFailure: false,
-    webUrl: cr.html_url,
+    webUrl: cr.html_url
   }));
 
   // Derive overall pipeline status from individual check runs
-  const statuses = jobs.map((j) => j.status);
+  const statuses = jobs.map(j => j.status);
   let overallStatus: string;
-  if (statuses.some((s) => s === "failed")) {
-    overallStatus = "failed";
-  } else if (statuses.some((s) => s === "running")) {
-    overallStatus = "running";
-  } else if (statuses.some((s) => s === "pending")) {
-    overallStatus = "pending";
-  } else if (statuses.every((s) => s === "success" || s === "skipped")) {
-    overallStatus = "success";
+  if (statuses.some(s => s === 'failed')) {
+    overallStatus = 'failed';
+  } else if (statuses.some(s => s === 'running')) {
+    overallStatus = 'running';
+  } else if (statuses.some(s => s === 'pending')) {
+    overallStatus = 'pending';
+  } else if (statuses.every(s => s === 'success' || s === 'skipped')) {
+    overallStatus = 'success';
   } else {
-    overallStatus = "pending";
+    overallStatus = 'pending';
   }
 
   return {
@@ -172,32 +177,32 @@ function toPipeline(
     status: overallStatus,
     createdAt: null,
     webUrl: `${prHtmlUrl}/checks`,
-    jobs,
+    jobs
   };
 }
 
 function normalizeCheckStatus(cr: GHCheckRun): string {
-  if (cr.status === "completed") {
+  if (cr.status === 'completed') {
     switch (cr.conclusion) {
-      case "success":
-        return "success";
-      case "failure":
-      case "timed_out":
-        return "failed";
-      case "cancelled":
-        return "canceled";
-      case "skipped":
-        return "skipped";
-      case "neutral":
-        return "success";
-      case "action_required":
-        return "manual";
+      case 'success':
+        return 'success';
+      case 'failure':
+      case 'timed_out':
+        return 'failed';
+      case 'cancelled':
+        return 'canceled';
+      case 'skipped':
+        return 'skipped';
+      case 'neutral':
+        return 'success';
+      case 'action_required':
+        return 'manual';
       default:
-        return "pending";
+        return 'pending';
     }
   }
-  if (cr.status === "in_progress") return "running";
-  return "pending"; // "queued"
+  if (cr.status === 'in_progress') return 'running';
+  return 'pending'; // "queued"
 }
 
 // ---------------------------------------------------------------------------
@@ -205,7 +210,7 @@ function normalizeCheckStatus(cr: GHCheckRun): string {
 // ---------------------------------------------------------------------------
 
 export class GitHubProvider implements GitProvider {
-  readonly providerName = "github" as const;
+  readonly providerName = 'github' as const;
   readonly baseURL: string;
   private readonly apiBase: string;
   private readonly token: string;
@@ -217,29 +222,46 @@ export class GitHubProvider implements GitProvider {
    * @param token — A GitHub PAT (classic or fine-grained) with `repo` scope.
    * @param options.logger — Optional logger; defaults to noop.
    */
-  constructor(baseURL: string, token: string, options: { logger?: ForgeLogger } = {}) {
-    this.baseURL = baseURL.replace(/\/$/, "");
+  constructor(
+    baseURL: string,
+    token: string,
+    options: { logger?: ForgeLogger } = {}
+  ) {
+    this.baseURL = baseURL.replace(/\/$/, '');
     this.token = token;
     this.log = options.logger ?? noopLogger;
 
     // API base: github.com uses api.github.com; GHES uses <host>/api/v3
     if (
-      this.baseURL === "https://github.com" ||
-      this.baseURL === "https://www.github.com"
+      this.baseURL === 'https://github.com' ||
+      this.baseURL === 'https://www.github.com'
     ) {
-      this.apiBase = "https://api.github.com";
+      this.apiBase = 'https://api.github.com';
     } else {
       this.apiBase = `${this.baseURL}/api/v3`;
     }
   }
 
+  // ── Capabilities ──────────────────────────────────────────────────────
+
+  readonly capabilities: ProviderCapabilities = {
+    canMerge: true,
+    canApprove: true,
+    canUnapprove: false,
+    canRebase: false,
+    canAutoMerge: false,
+    canResolveDiscussions: false,
+    canRetryPipeline: true,
+    canRequestReReview: true
+  };
+
   // ── GitProvider interface ─────────────────────────────────────────────────
 
   async validateToken(): Promise<UserRef> {
-    const res = await this.api("GET", "/user");
+    const res = await this.api('GET', '/user');
     if (!res.ok) {
       throw new Error(
-        `GitHub token validation failed: ${res.status} ${res.statusText}`,
+        `GitHub token validation failed: ${res.status} ${res.statusText}`
       );
     }
     const user = (await res.json()) as GHUser;
@@ -252,9 +274,9 @@ export class GitHubProvider implements GitProvider {
     // review requests. We merge the results.
 
     const [authored, reviewRequested, assigned] = await Promise.all([
-      this.searchPRs("is:open is:pr author:@me"),
-      this.searchPRs("is:open is:pr review-requested:@me"),
-      this.searchPRs("is:open is:pr assignee:@me"),
+      this.searchPRs('is:open is:pr author:@me'),
+      this.searchPRs('is:open is:pr review-requested:@me'),
+      this.searchPRs('is:open is:pr assignee:@me')
     ]);
 
     // Deduplicate by PR number+repo
@@ -274,65 +296,67 @@ export class GitHubProvider implements GitProvider {
       }
     };
 
-    addAll(authored, "author");
-    addAll(reviewRequested, "reviewer");
-    addAll(assigned, "assignee");
+    addAll(authored, 'author');
+    addAll(reviewRequested, 'reviewer');
+    addAll(assigned, 'assignee');
 
     // For each unique PR, fetch check runs and reviews in parallel
     const entries = [...byKey.entries()];
     const results = await Promise.all(
       entries.map(async ([key, pr]) => {
-        const prRoles = roles.get(key) ?? ["author"];
+        const prRoles = roles.get(key) ?? ['author'];
         const [reviews, checkRuns] = await Promise.all([
           this.fetchReviews(pr.base.repo.full_name, pr.number),
-          this.fetchCheckRuns(pr.base.repo.full_name, pr.head.sha),
+          this.fetchCheckRuns(pr.base.repo.full_name, pr.head.sha)
         ]);
         return this.toPullRequest(pr, prRoles, reviews, checkRuns);
-      }),
+      })
     );
 
-    this.log.debug("GitHubProvider.fetchPullRequests", { count: results.length });
+    this.log.debug('GitHubProvider.fetchPullRequests', {
+      count: results.length
+    });
     return results;
   }
 
   async fetchSingleMR(
     projectPath: string,
     mrIid: number,
-    _currentUserNumericId: number | null,
+    _currentUserNumericId: number | null
   ): Promise<PullRequest | null> {
     // projectPath for GitHub is "owner/repo"
     try {
-      const res = await this.api("GET", `/repos/${projectPath}/pulls/${mrIid}`);
+      const res = await this.api('GET', `/repos/${projectPath}/pulls/${mrIid}`);
       if (!res.ok) return null;
 
       const pr = (await res.json()) as GHPullRequest;
       const [reviews, checkRuns] = await Promise.all([
         this.fetchReviews(projectPath, mrIid),
-        this.fetchCheckRuns(projectPath, pr.head.sha),
+        this.fetchCheckRuns(projectPath, pr.head.sha)
       ]);
 
       // Determine roles from the current user
-      const currentUser = await this.api("GET", "/user");
+      const currentUser = await this.api('GET', '/user');
       const currentUserData = (await currentUser.json()) as GHUser;
       const prRoles: string[] = [];
-      if (pr.user.id === currentUserData.id) prRoles.push("author");
-      if (pr.assignees.some((a) => a.id === currentUserData.id))
-        prRoles.push("assignee");
-      if (pr.requested_reviewers.some((r) => r.id === currentUserData.id))
-        prRoles.push("reviewer");
+      if (pr.user.id === currentUserData.id) prRoles.push('author');
+      if (pr.assignees.some(a => a.id === currentUserData.id))
+        prRoles.push('assignee');
+      if (pr.requested_reviewers.some(r => r.id === currentUserData.id))
+        prRoles.push('reviewer');
 
       return this.toPullRequest(
         pr,
-        prRoles.length > 0 ? prRoles : ["author"],
+        prRoles.length > 0 ? prRoles : ['author'],
         reviews,
-        checkRuns,
+        checkRuns
       );
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      this.log.warn("GitHubProvider.fetchSingleMR failed", {
+      this.log.warn('GitHubProvider.fetchSingleMR failed', {
         projectPath,
         mrIid,
-        message,
+        message
       });
       return null;
     }
@@ -340,11 +364,11 @@ export class GitHubProvider implements GitProvider {
 
   async fetchMRDiscussions(
     repositoryId: string,
-    mrIid: number,
+    mrIid: number
   ): Promise<MRDetail> {
-    const repoId = parseInt(repositoryId.split(":").pop() ?? "0", 10);
+    const repoId = parseInt(repositoryId.split(':').pop() ?? '0', 10);
     // We need the repo full_name. For now, look it up from the API.
-    const repoRes = await this.api("GET", `/repositories/${repoId}`);
+    const repoRes = await this.api('GET', `/repositories/${repoId}`);
     if (!repoRes.ok) {
       throw new Error(`Failed to fetch repo: ${repoRes.status}`);
     }
@@ -353,11 +377,11 @@ export class GitHubProvider implements GitProvider {
     // Fetch review comments (diff-level) and issue comments (PR-level)
     const [reviewComments, issueComments] = await Promise.all([
       this.fetchAllPages<GHComment>(
-        `/repos/${repo.full_name}/pulls/${mrIid}/comments?per_page=100`,
+        `/repos/${repo.full_name}/pulls/${mrIid}/comments?per_page=100`
       ),
       this.fetchAllPages<GHComment>(
-        `/repos/${repo.full_name}/issues/${mrIid}/comments?per_page=100`,
-      ),
+        `/repos/${repo.full_name}/issues/${mrIid}/comments?per_page=100`
+      )
     ]);
 
     // Group review comments into threads (by pull_request_review_id and in_reply_to_id)
@@ -369,7 +393,7 @@ export class GitHubProvider implements GitProvider {
         id: `gh-issue-comment-${c.id}`,
         resolvable: null,
         resolved: null,
-        notes: [toNote(c)],
+        notes: [toNote(c)]
       });
     }
 
@@ -385,47 +409,444 @@ export class GitHubProvider implements GitProvider {
     for (const [rootId, comments] of threadMap) {
       comments.sort(
         (a, b) =>
-          new Date(a.created_at).getTime() - new Date(b.created_at).getTime(),
+          new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
       );
       discussions.push({
         id: `gh-review-thread-${rootId}`,
         resolvable: true,
         resolved: null, // GitHub doesn't have a native "resolved" state on review threads
-        notes: comments.map(toNote),
+        notes: comments.map(toNote)
       });
     }
 
     return { mrIid, repositoryId, discussions };
   }
 
+  async fetchBranchProtectionRules(
+    projectPath: string
+  ): Promise<BranchProtectionRule[]> {
+    const res = await this.api(
+      'GET',
+      `/repos/${projectPath}/branches?protected=true&per_page=100`
+    );
+    if (!res.ok) {
+      throw new Error(
+        `fetchBranchProtectionRules failed: ${res.status} ${await res.text()}`
+      );
+    }
+    const branches = (await res.json()) as Array<{
+      name: string;
+      protected: boolean;
+      protection?: {
+        enabled: boolean;
+        required_status_checks?: {
+          enforcement_level: string;
+          contexts: string[];
+        } | null;
+      };
+    }>;
+
+    const rules: BranchProtectionRule[] = [];
+    for (const b of branches) {
+      if (!b.protected) continue;
+      // Fetch detailed protection for each protected branch
+      const detailRes = await this.api(
+        'GET',
+        `/repos/${projectPath}/branches/${encodeURIComponent(b.name)}/protection`
+      );
+      if (!detailRes.ok) {
+        rules.push({
+          pattern: b.name,
+          allowForcePush: false,
+          allowDeletion: false,
+          requiredApprovals: 0,
+          requireStatusChecks: false
+        });
+        continue;
+      }
+      const detail = (await detailRes.json()) as {
+        allow_force_pushes?: { enabled: boolean };
+        allow_deletions?: { enabled: boolean };
+        required_pull_request_reviews?: {
+          required_approving_review_count?: number;
+        } | null;
+        required_status_checks?: { strict: boolean; contexts: string[] } | null;
+      };
+      rules.push({
+        pattern: b.name,
+        allowForcePush: detail.allow_force_pushes?.enabled ?? false,
+        allowDeletion: detail.allow_deletions?.enabled ?? false,
+        requiredApprovals:
+          detail.required_pull_request_reviews
+            ?.required_approving_review_count ?? 0,
+        requireStatusChecks:
+          detail.required_status_checks !== null &&
+          detail.required_status_checks !== undefined,
+        raw: detail as unknown as Record<string, unknown>
+      });
+    }
+    return rules;
+  }
+
+  async deleteBranch(projectPath: string, branch: string): Promise<void> {
+    const res = await this.api(
+      'DELETE',
+      `/repos/${projectPath}/git/refs/heads/${encodeURIComponent(branch)}`
+    );
+    if (!res.ok) {
+      throw new Error(`deleteBranch failed: ${res.status} ${await res.text()}`);
+    }
+  }
+
+  async fetchPullRequestByBranch(
+    projectPath: string,
+    sourceBranch: string
+  ): Promise<PullRequest | null> {
+    const res = await this.api(
+      'GET',
+      `/repos/${projectPath}/pulls?head=${projectPath.split('/')[0]}:${encodeURIComponent(sourceBranch)}&state=open&per_page=1`
+    );
+    if (!res.ok) {
+      this.log.warn('fetchPullRequestByBranch failed', {
+        projectPath,
+        sourceBranch,
+        status: res.status
+      });
+      return null;
+    }
+    const prs = (await res.json()) as GHPullRequest[];
+    if (!prs[0]) return null;
+    return this.fetchSingleMR(projectPath, prs[0].number, null);
+  }
+
+  async createPullRequest(input: CreatePullRequestInput): Promise<PullRequest> {
+    const body: Record<string, unknown> = {
+      head: input.sourceBranch,
+      base: input.targetBranch,
+      title: input.title
+    };
+    if (input.description != null) body.body = input.description;
+    if (input.draft != null) body.draft = input.draft;
+
+    const res = await this.api(
+      'POST',
+      `/repos/${input.projectPath}/pulls`,
+      body
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`createPullRequest failed: ${res.status} ${text}`);
+    }
+    const created = (await res.json()) as GHPullRequest;
+
+    // GitHub doesn't support reviewers/assignees/labels on create — add them separately
+    if (input.reviewers?.length) {
+      await this.api(
+        'POST',
+        `/repos/${input.projectPath}/pulls/${created.number}/requested_reviewers`,
+        {
+          reviewers: input.reviewers
+        }
+      );
+    }
+    if (input.assignees?.length) {
+      await this.api(
+        'POST',
+        `/repos/${input.projectPath}/issues/${created.number}/assignees`,
+        {
+          assignees: input.assignees
+        }
+      );
+    }
+    if (input.labels?.length) {
+      await this.api(
+        'POST',
+        `/repos/${input.projectPath}/issues/${created.number}/labels`,
+        {
+          labels: input.labels
+        }
+      );
+    }
+
+    const pr = await this.fetchSingleMR(
+      input.projectPath,
+      created.number,
+      null
+    );
+    if (!pr) throw new Error('Created PR but failed to fetch it back');
+    return pr;
+  }
+
+  async updatePullRequest(
+    projectPath: string,
+    mrIid: number,
+    input: UpdatePullRequestInput
+  ): Promise<PullRequest> {
+    const body: Record<string, unknown> = {};
+    if (input.title != null) body.title = input.title;
+    if (input.description != null) body.body = input.description;
+    if (input.draft != null) body.draft = input.draft;
+    if (input.targetBranch != null) body.base = input.targetBranch;
+    if (input.stateEvent)
+      body.state = input.stateEvent === 'close' ? 'closed' : 'open';
+
+    const res = await this.api(
+      'PATCH',
+      `/repos/${projectPath}/pulls/${mrIid}`,
+      body
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`updatePullRequest failed: ${res.status} ${text}`);
+    }
+
+    // Handle reviewers/assignees/labels replacement if provided
+    if (input.reviewers) {
+      await this.api(
+        'POST',
+        `/repos/${projectPath}/pulls/${mrIid}/requested_reviewers`,
+        {
+          reviewers: input.reviewers
+        }
+      );
+    }
+    if (input.assignees) {
+      await this.api(
+        'POST',
+        `/repos/${projectPath}/issues/${mrIid}/assignees`,
+        {
+          assignees: input.assignees
+        }
+      );
+    }
+    if (input.labels) {
+      await this.api('PUT', `/repos/${projectPath}/issues/${mrIid}/labels`, {
+        labels: input.labels
+      });
+    }
+
+    const pr = await this.fetchSingleMR(projectPath, mrIid, null);
+    if (!pr) throw new Error('Updated PR but failed to fetch it back');
+    return pr;
+  }
+
   async restRequest(
     method: string,
     path: string,
-    body?: unknown,
+    body?: unknown
   ): Promise<Response> {
     return this.api(method, path, body);
   }
 
+  // ── MR lifecycle mutations ──────────────────────────────────────────────
+
+  async mergePullRequest(
+    projectPath: string,
+    mrIid: number,
+    input?: MergePullRequestInput
+  ): Promise<PullRequest> {
+    const body: Record<string, unknown> = {};
+    if (input?.commitMessage != null) body.commit_title = input.commitMessage;
+    if (input?.squashCommitMessage != null)
+      body.commit_title = input.squashCommitMessage;
+    if (input?.shouldRemoveSourceBranch != null)
+      body.delete_branch = input.shouldRemoveSourceBranch;
+    if (input?.sha != null) body.sha = input.sha;
+
+    // Map mergeMethod / squash to GitHub's merge_method parameter.
+    // GitHub accepts: "merge", "squash", "rebase".
+    if (input?.mergeMethod) {
+      body.merge_method = input.mergeMethod;
+    } else if (input?.squash) {
+      body.merge_method = 'squash';
+    }
+
+    const res = await this.api(
+      'PUT',
+      `/repos/${projectPath}/pulls/${mrIid}/merge`,
+      body
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`mergePullRequest failed: ${res.status} ${text}`);
+    }
+    const pr = await this.fetchSingleMR(projectPath, mrIid, null);
+    if (!pr) throw new Error('Merged PR but failed to fetch it back');
+    return pr;
+  }
+
+  async approvePullRequest(projectPath: string, mrIid: number): Promise<void> {
+    const res = await this.api(
+      'POST',
+      `/repos/${projectPath}/pulls/${mrIid}/reviews`,
+      {
+        event: 'APPROVE'
+      }
+    );
+    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> {
+    // TODO: GitHub does not support unapproving via REST API.
+    // A possible workaround is to dismiss the review via
+    //   PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals
+    // but that requires knowing the review ID and is semantically different
+    // (dismissal vs. unapproval). Leave as stub until a use case emerges.
+    throw new Error(
+      'unapprovePullRequest is not supported by GitHub. ' +
+        'Check provider.capabilities.canUnapprove before calling.'
+    );
+  }
+
+  async rebasePullRequest(_projectPath: string, _mrIid: number): Promise<void> {
+    // TODO: GitHub has no native "rebase" API for pull requests.
+    // The closest equivalent is the update-branch API:
+    //   PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch
+    // which updates the PR branch with the latest from the base branch,
+    // but it's a merge (not a rebase). True rebase requires pushing
+    // locally rebased commits.
+    throw new Error(
+      'rebasePullRequest is not supported by GitHub. ' +
+        'Check provider.capabilities.canRebase before calling.'
+    );
+  }
+
+  async setAutoMerge(_projectPath: string, _mrIid: number): Promise<void> {
+    // TODO: GitHub supports auto-merge via GraphQL mutation:
+    //   mutation { enablePullRequestAutoMerge(input: { pullRequestId: "..." }) { ... } }
+    // Requires the repository to have "Allow auto-merge" enabled in settings.
+    // The REST API does not support this — GraphQL only.
+    throw new Error(
+      'setAutoMerge is not supported by the GitHub REST API. ' +
+        'Check provider.capabilities.canAutoMerge before calling.'
+    );
+  }
+
+  async cancelAutoMerge(_projectPath: string, _mrIid: number): Promise<void> {
+    // TODO: GitHub GraphQL mutation:
+    //   mutation { disablePullRequestAutoMerge(input: { pullRequestId: "..." }) { ... } }
+    // Same pre-requisites as setAutoMerge.
+    throw new Error(
+      'cancelAutoMerge is not supported by the GitHub REST API. ' +
+        'Check provider.capabilities.canAutoMerge before calling.'
+    );
+  }
+
+  // ── Discussion mutations ────────────────────────────────────────────────
+
+  async resolveDiscussion(
+    _projectPath: string,
+    _mrIid: number,
+    _discussionId: string
+  ): Promise<void> {
+    // TODO: GitHub GraphQL mutation:
+    //   mutation { resolveReviewThread(input: { threadId: "..." }) { ... } }
+    // REST API does not support resolving review threads.
+    throw new Error(
+      'resolveDiscussion is not supported by the GitHub REST API. ' +
+        'Check provider.capabilities.canResolveDiscussions before calling.'
+    );
+  }
+
+  async unresolveDiscussion(
+    _projectPath: string,
+    _mrIid: number,
+    _discussionId: string
+  ): Promise<void> {
+    // TODO: GitHub GraphQL mutation:
+    //   mutation { unresolveReviewThread(input: { threadId: "..." }) { ... } }
+    // REST API does not support unresolving review threads.
+    throw new Error(
+      'unresolveDiscussion is not supported by the GitHub REST API. ' +
+        'Check provider.capabilities.canResolveDiscussions before calling.'
+    );
+  }
+
+  // ── Pipeline mutations ──────────────────────────────────────────────────
+
+  async retryPipeline(projectPath: string, pipelineId: number): Promise<void> {
+    // GitHub Actions: re-run a workflow run.
+    // pipelineId maps to the workflow run ID.
+    const res = await this.api(
+      'POST',
+      `/repos/${projectPath}/actions/runs/${pipelineId}/rerun`
+    );
+    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> {
+    // GitHub: POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers
+    // If no usernames provided, we'd need to fetch the current PR to get
+    // the existing reviewer list. For now, require explicit usernames.
+    if (!reviewerUsernames?.length) {
+      // Fetch current reviewers from the PR
+      const prRes = await this.api(
+        'GET',
+        `/repos/${projectPath}/pulls/${mrIid}`
+      );
+      if (!prRes.ok) {
+        throw new Error(`requestReReview: failed to fetch PR: ${prRes.status}`);
+      }
+      const pr = (await prRes.json()) as GHPullRequest;
+      reviewerUsernames = pr.requested_reviewers.map(r => r.login);
+      if (!reviewerUsernames.length) {
+        // Nothing to re-request
+        return;
+      }
+    }
+
+    const res = await this.api(
+      'POST',
+      `/repos/${projectPath}/pulls/${mrIid}/requested_reviewers`,
+      { reviewers: reviewerUsernames }
+    );
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(
+        `requestReReview failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ''}`
+      );
+    }
+  }
+
   // ── Private helpers ─────────────────────────────────────────────────────
 
   private async api(
     method: string,
     path: string,
-    body?: unknown,
+    body?: unknown
   ): Promise<Response> {
     const url = `${this.apiBase}${path}`;
     const headers: Record<string, string> = {
       Authorization: `Bearer ${this.token}`,
-      Accept: "application/vnd.github+json",
-      "X-GitHub-Api-Version": "2022-11-28",
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28'
     };
     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
     });
   }
 
@@ -436,11 +857,11 @@ export class GitHubProvider implements GitProvider {
   private async searchPRs(qualifiers: string): Promise<GHPullRequest[]> {
     const q = encodeURIComponent(qualifiers);
     const res = await this.api(
-      "GET",
-      `/search/issues?q=${q}&per_page=100&sort=updated`,
+      'GET',
+      `/search/issues?q=${q}&per_page=100&sort=updated`
     );
     if (!res.ok) {
-      this.log.warn("GitHub search failed", { status: res.status, qualifiers });
+      this.log.warn('GitHub search failed', { status: res.status, qualifiers });
       return [];
     }
 
@@ -454,16 +875,16 @@ export class GitHubProvider implements GitProvider {
 
     // The search API returns issue-shaped results; fetch full PR details
     const prPromises = data.items
-      .filter((item) => item.pull_request) // Only PRs
-      .map(async (item) => {
+      .filter(item => item.pull_request) // Only PRs
+      .map(async item => {
         // Extract owner/repo from repository_url
         const repoPath = item.repository_url.replace(
           `${this.apiBase}/repos/`,
-          "",
+          ''
         );
         const res = await this.api(
-          "GET",
-          `/repos/${repoPath}/pulls/${item.number}`,
+          'GET',
+          `/repos/${repoPath}/pulls/${item.number}`
         );
         if (!res.ok) return null;
         return (await res.json()) as GHPullRequest;
@@ -475,21 +896,21 @@ export class GitHubProvider implements GitProvider {
 
   private async fetchReviews(
     repoPath: string,
-    prNumber: number,
+    prNumber: number
   ): Promise<GHReview[]> {
     return this.fetchAllPages<GHReview>(
-      `/repos/${repoPath}/pulls/${prNumber}/reviews?per_page=100`,
+      `/repos/${repoPath}/pulls/${prNumber}/reviews?per_page=100`
     );
   }
 
   private async fetchCheckRuns(
     repoPath: string,
-    sha: string,
+    sha: string
   ): Promise<GHCheckRun[]> {
     try {
       const res = await this.api(
-        "GET",
-        `/repos/${repoPath}/commits/${sha}/check-runs?per_page=100`,
+        'GET',
+        `/repos/${repoPath}/commits/${sha}/check-runs?per_page=100`
       );
       if (!res.ok) return [];
       const data = (await res.json()) as GHCheckSuite;
@@ -504,17 +925,17 @@ export class GitHubProvider implements GitProvider {
     let url: string | null = path;
 
     while (url) {
-      const res = await this.api("GET", url);
+      const res = await this.api('GET', url);
       if (!res.ok) break;
       const items = (await res.json()) as T[];
       results.push(...items);
 
       // Parse Link header for pagination
-      const linkHeader = res.headers.get("Link");
+      const linkHeader = res.headers.get('Link');
       const nextMatch = linkHeader?.match(/<([^>]+)>;\s*rel="next"/);
       if (nextMatch) {
         // Strip apiBase prefix — `api()` will re-add it
-        url = nextMatch[1]!.replace(this.apiBase, "");
+        url = nextMatch[1]!.replace(this.apiBase, '');
       } else {
         url = null;
       }
@@ -530,14 +951,13 @@ export class GitHubProvider implements GitProvider {
     pr: GHPullRequest,
     roles: string[],
     reviews: GHReview[],
-    checkRuns: GHCheckRun[],
+    checkRuns: GHCheckRun[]
   ): PullRequest {
     // Compute approvals: latest review per user, count "APPROVED" ones
     const latestReviewByUser = new Map<number, GHReview>();
     for (const r of reviews.sort(
       (a, b) =>
-        new Date(a.submitted_at).getTime() -
-        new Date(b.submitted_at).getTime(),
+        new Date(a.submitted_at).getTime() - new Date(b.submitted_at).getTime()
     )) {
       latestReviewByUser.set(r.user.id, r);
     }
@@ -545,9 +965,9 @@ export class GitHubProvider implements GitProvider {
     const approvedBy: UserRef[] = [];
     let changesRequested = 0;
     for (const r of latestReviewByUser.values()) {
-      if (r.state === "APPROVED") {
+      if (r.state === 'APPROVED') {
         approvedBy.push(toUserRef(r.user));
-      } else if (r.state === "CHANGES_REQUESTED") {
+      } else if (r.state === 'CHANGES_REQUESTED') {
         changesRequested++;
       }
     }
@@ -561,13 +981,12 @@ export class GitHubProvider implements GitProvider {
         ? {
             additions: pr.additions!,
             deletions: pr.deletions ?? 0,
-            filesChanged: pr.changed_files ?? 0,
+            filesChanged: pr.changed_files ?? 0
           }
         : null;
 
     // Conflicts: GitHub's mergeable_state "dirty" indicates conflicts
-    const conflicts =
-      pr.mergeable === false || pr.mergeable_state === "dirty";
+    const conflicts = pr.mergeable === false || pr.mergeable_state === 'dirty';
 
     const pipeline = toPipeline(checkRuns, pr.html_url);
 
@@ -596,7 +1015,7 @@ export class GitHubProvider implements GitProvider {
       approved: approvedBy.length > 0 && changesRequested === 0,
       approvedBy,
       diffStats,
-      detailedMergeStatus: null, // GitHub-specific status not applicable
+      detailedMergeStatus: null // GitHub-specific status not applicable
     };
   }
 }
@@ -612,7 +1031,7 @@ function toNote(c: GHComment): Note {
         oldPath: c.path,
         newLine: c.line ?? null,
         oldLine: c.original_line ?? null,
-        positionType: c.path ? "text" : null,
+        positionType: c.path ? 'text' : null
       }
     : null;
 
@@ -622,10 +1041,10 @@ function toNote(c: GHComment): Note {
     author: toNoteAuthor(c.user),
     createdAt: c.created_at,
     system: false,
-    type: c.path ? "DiffNote" : "DiscussionNote",
+    type: c.path ? 'DiffNote' : 'DiscussionNote',
     resolvable: c.path ? true : null,
     resolved: null,
-    position,
+    position
   };
 }
 
@@ -634,6 +1053,6 @@ function toNoteAuthor(u: GHUser): NoteAuthor {
     id: `github:user:${u.id}`,
     username: u.login,
     name: u.name ?? u.login,
-    avatarUrl: u.avatar_url,
+    avatarUrl: u.avatar_url
   };
 }