@forge-glance/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,972 @@
+// src/GitProvider.ts
+function parseRepoId(repositoryId) {
+  const parts = repositoryId.split(":");
+  return parseInt(parts.at(-1) ?? "0", 10);
+}
+function repoIdProvider(repositoryId) {
+  return repositoryId.split(":")[0] ?? "unknown";
+}
+
+// src/logger.ts
+var noopLogger = {
+  debug() {},
+  info() {},
+  warn() {},
+  error() {}
+};
+
+// src/MRDetailFetcher.ts
+class MRDetailFetcher {
+  baseURL;
+  token;
+  log;
+  constructor(baseURL, token, options = {}) {
+    this.baseURL = baseURL.replace(/\/$/, "");
+    this.token = token;
+    this.log = options.logger ?? noopLogger;
+  }
+  async fetchDetail(projectId, mrIid) {
+    const url = `${this.baseURL}/api/v4/projects/${projectId}/merge_requests/${mrIid}/discussions?per_page=100`;
+    const res = await fetch(url, {
+      headers: { "PRIVATE-TOKEN": this.token }
+    });
+    if (!res.ok) {
+      throw new Error(`MR discussions fetch failed: ${res.status} ${res.statusText}`);
+    }
+    const raw = await res.json();
+    const discussions = raw.map((d) => ({
+      id: d.id,
+      resolvable: null,
+      resolved: null,
+      notes: d.notes.map(toNote)
+    }));
+    this.log.debug("MRDetailFetcher.fetchDetail", {
+      projectId,
+      mrIid,
+      discussionCount: discussions.length
+    });
+    return { mrIid, repositoryId: `gitlab:${projectId}`, discussions };
+  }
+}
+function toNote(n) {
+  return {
+    id: n.id,
+    body: n.body,
+    author: toAuthor(n.author),
+    createdAt: n.created_at,
+    system: n.system,
+    type: n.type,
+    resolvable: n.resolvable ?? null,
+    resolved: n.resolved ?? null,
+    position: n.position ? toPosition(n.position) : null
+  };
+}
+function toAuthor(a) {
+  return {
+    id: `gitlab:user:${a.id}`,
+    username: a.username,
+    name: a.name,
+    avatarUrl: a.avatar_url
+  };
+}
+function toPosition(p) {
+  return {
+    newPath: p.new_path ?? null,
+    oldPath: p.old_path ?? null,
+    newLine: p.new_line ?? null,
+    oldLine: p.old_line ?? null,
+    positionType: p.position_type ?? null
+  };
+}
+
+// src/GitLabProvider.ts
+function parseGitLabRepoId(repositoryId) {
+  const parts = repositoryId.split(":");
+  return parseInt(parts.at(-1) ?? "0", 10);
+}
+var MR_DASHBOARD_FRAGMENT = `
+  fragment MRDashboardFields on MergeRequest {
+    id iid projectId title description state draft
+    sourceBranch targetBranch webUrl
+    diffHeadSha
+    updatedAt createdAt
+    conflicts
+    detailedMergeStatus
+    approved
+    diffStatsSummary { additions deletions fileCount }
+    author { id username name avatarUrl }
+    assignees(first: 20) { nodes { id username name avatarUrl } }
+    reviewers(first: 20) { nodes { id username name avatarUrl } }
+    approvedBy(first: 20) { nodes { id username name avatarUrl } }
+    approvalsLeft
+    resolvableDiscussionsCount
+    resolvedDiscussionsCount
+    headPipeline {
+      id iid status
+      createdAt
+      path
+      stages(first: 20) { nodes {
+        name
+        jobs(first: 50) { nodes {
+          id name status
+          allowFailure
+          webPath
+          stage { name }
+        }}
+      }}
+    }
+  }
+`;
+var AUTHORED_QUERY = `
+  query GlanceDashboardAuthored {
+    currentUser {
+      authoredMergeRequests(state: opened, first: 100) {
+        nodes { ...MRDashboardFields }
+      }
+    }
+  }
+  ${MR_DASHBOARD_FRAGMENT}
+`;
+var REVIEWING_QUERY = `
+  query GlanceDashboardReviewing {
+    currentUser {
+      reviewRequestedMergeRequests(state: opened, first: 100) {
+        nodes { ...MRDashboardFields }
+      }
+    }
+  }
+  ${MR_DASHBOARD_FRAGMENT}
+`;
+var ASSIGNED_QUERY = `
+  query GlanceDashboardAssigned {
+    currentUser {
+      assignedMergeRequests(state: opened, first: 100) {
+        nodes { ...MRDashboardFields }
+      }
+    }
+  }
+  ${MR_DASHBOARD_FRAGMENT}
+`;
+function numericId(gid) {
+  const parts = gid.split("/");
+  return parseInt(parts[parts.length - 1] ?? "0", 10);
+}
+function domainId(type, id) {
+  return `gitlab:${type}:${id}`;
+}
+function toUserRef(u) {
+  return {
+    id: `gitlab:user:${numericId(u.id)}`,
+    username: u.username,
+    name: u.name,
+    avatarUrl: u.avatarUrl
+  };
+}
+function toPipeline(p, baseURL) {
+  const allJobs = 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
+  })));
+  return {
+    id: domainId("pipeline", numericId(p.id)),
+    status: normalizePipelineStatus(p),
+    createdAt: p.createdAt,
+    webUrl: p.path ? `${baseURL}${p.path}` : null,
+    jobs: allJobs
+  };
+}
+function normalizePipelineStatus(p) {
+  const allJobs = p.stages.nodes.flatMap((s) => s.jobs.nodes);
+  const hasAllowFailFailed = allJobs.some((j) => j.allowFailure && j.status === "failed");
+  if (p.status === "success" && hasAllowFailFailed) {
+    return "success_with_warnings";
+  }
+  return p.status;
+}
+function toMR(gql, role, baseURL) {
+  const resolvable = gql.resolvableDiscussionsCount ?? 0;
+  const resolved = gql.resolvedDiscussionsCount ?? 0;
+  const unresolvedThreadCount = Math.max(0, resolvable - resolved);
+  const diffStats = gql.diffStatsSummary ? {
+    additions: gql.diffStatsSummary.additions,
+    deletions: gql.diffStatsSummary.deletions,
+    filesChanged: gql.diffStatsSummary.fileCount
+  } : null;
+  return {
+    id: `gitlab:mr:${numericId(gql.id)}`,
+    iid: parseInt(gql.iid, 10),
+    repositoryId: `gitlab:${gql.projectId}`,
+    title: gql.title,
+    description: gql.description ?? null,
+    state: gql.state,
+    draft: gql.draft,
+    conflicts: gql.conflicts || gql.detailedMergeStatus === "conflict",
+    webUrl: gql.webUrl,
+    sourceBranch: gql.sourceBranch,
+    targetBranch: gql.targetBranch,
+    createdAt: gql.createdAt,
+    updatedAt: gql.updatedAt,
+    sha: gql.diffHeadSha,
+    author: toUserRef(gql.author),
+    assignees: gql.assignees.nodes.map(toUserRef),
+    reviewers: gql.reviewers.nodes.map(toUserRef),
+    roles: [role],
+    pipeline: gql.headPipeline ? toPipeline(gql.headPipeline, baseURL) : null,
+    unresolvedThreadCount,
+    approvalsLeft: gql.approvalsLeft ?? 0,
+    approved: gql.approved ?? false,
+    approvedBy: gql.approvedBy.nodes.map(toUserRef),
+    diffStats,
+    detailedMergeStatus: gql.detailedMergeStatus ?? null
+  };
+}
+var MR_DETAIL_QUERY = `
+  query GlanceMRDetail($projectPath: ID!, $iid: String!) {
+    project(fullPath: $projectPath) {
+      mergeRequest(iid: $iid) {
+        ...MRDashboardFields
+      }
+    }
+  }
+  ${MR_DASHBOARD_FRAGMENT}
+`;
+
+class GitLabProvider {
+  providerName = "gitlab";
+  baseURL;
+  token;
+  log;
+  mrDetailFetcher;
+  constructor(baseURL, token, options = {}) {
+    this.baseURL = baseURL.replace(/\/$/, "");
+    this.token = token;
+    this.log = options.logger ?? noopLogger;
+    this.mrDetailFetcher = new MRDetailFetcher(this.baseURL, token, { logger: this.log });
+  }
+  async validateToken() {
+    const url = `${this.baseURL}/api/v4/user`;
+    const res = await fetch(url, {
+      headers: { "PRIVATE-TOKEN": this.token }
+    });
+    if (!res.ok) {
+      throw new Error(`Token validation failed: ${res.status} ${res.statusText}`);
+    }
+    const user = await res.json();
+    return {
+      id: `gitlab:user:${user.id}`,
+      username: user.username,
+      name: user.name,
+      avatarUrl: user.avatar_url
+    };
+  }
+  async fetchSingleMR(projectPath, mrIid, currentUserNumericId) {
+    let resp;
+    try {
+      resp = await this.runQuery(MR_DETAIL_QUERY, {
+        projectPath,
+        iid: String(mrIid)
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.warn("fetchSingleMR failed", { projectPath, mrIid, message });
+      return null;
+    }
+    const gql = resp.project?.mergeRequest;
+    if (!gql)
+      return null;
+    const roles = [];
+    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");
+    }
+    const pr = toMR(gql, roles[0] ?? "author", this.baseURL);
+    pr.roles = roles.length > 0 ? roles : pr.roles;
+    return pr;
+  }
+  async fetchPullRequests() {
+    const [authored, reviewing, assigned] = await Promise.all([
+      this.runQuery(AUTHORED_QUERY),
+      this.runQuery(REVIEWING_QUERY),
+      this.runQuery(ASSIGNED_QUERY)
+    ]);
+    const byId = new Map;
+    const addAll = (mrs, role) => {
+      for (const gql of mrs) {
+        const existing = byId.get(gql.id);
+        if (existing) {
+          if (!existing.roles.includes(role)) {
+            existing.roles.push(role);
+          }
+        } else {
+          byId.set(gql.id, toMR(gql, role, this.baseURL));
+        }
+      }
+    };
+    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 });
+    return prs;
+  }
+  async fetchMRDiscussions(repositoryId, mrIid) {
+    const projectId = parseGitLabRepoId(repositoryId);
+    return this.mrDetailFetcher.fetchDetail(projectId, mrIid);
+  }
+  async restRequest(method, path, body) {
+    const url = `${this.baseURL}${path}`;
+    const headers = {
+      "PRIVATE-TOKEN": this.token
+    };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    return fetch(url, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+  }
+  async runQuery(query, variables) {
+    const url = `${this.baseURL}/api/graphql`;
+    const body = JSON.stringify({ query, variables: variables ?? {} });
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`
+      },
+      body
+    });
+    if (!res.ok) {
+      throw new Error(`GraphQL request failed: ${res.status} ${res.statusText}`);
+    }
+    const envelope = await res.json();
+    if (envelope.errors?.length) {
+      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");
+    }
+    return envelope.data;
+  }
+}
+
+// src/GitHubProvider.ts
+function toUserRef2(u) {
+  return {
+    id: `github:user:${u.id}`,
+    username: u.login,
+    name: u.name ?? u.login,
+    avatarUrl: u.avatar_url
+  };
+}
+function normalizePRState(pr) {
+  if (pr.merged_at)
+    return "merged";
+  if (pr.state === "open")
+    return "opened";
+  return "closed";
+}
+function toPipeline2(checkRuns, prHtmlUrl) {
+  if (checkRuns.length === 0)
+    return null;
+  const jobs = checkRuns.map((cr) => ({
+    id: `github:check:${cr.id}`,
+    name: cr.name,
+    stage: "checks",
+    status: normalizeCheckStatus(cr),
+    allowFailure: false,
+    webUrl: cr.html_url
+  }));
+  const statuses = jobs.map((j) => j.status);
+  let overallStatus;
+  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";
+  }
+  return {
+    id: `github:checks:${prHtmlUrl}`,
+    status: overallStatus,
+    createdAt: null,
+    webUrl: `${prHtmlUrl}/checks`,
+    jobs
+  };
+}
+function normalizeCheckStatus(cr) {
+  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";
+      default:
+        return "pending";
+    }
+  }
+  if (cr.status === "in_progress")
+    return "running";
+  return "pending";
+}
+
+class GitHubProvider {
+  providerName = "github";
+  baseURL;
+  apiBase;
+  token;
+  log;
+  constructor(baseURL, token, options = {}) {
+    this.baseURL = baseURL.replace(/\/$/, "");
+    this.token = token;
+    this.log = options.logger ?? noopLogger;
+    if (this.baseURL === "https://github.com" || this.baseURL === "https://www.github.com") {
+      this.apiBase = "https://api.github.com";
+    } else {
+      this.apiBase = `${this.baseURL}/api/v3`;
+    }
+  }
+  async validateToken() {
+    const res = await this.api("GET", "/user");
+    if (!res.ok) {
+      throw new Error(`GitHub token validation failed: ${res.status} ${res.statusText}`);
+    }
+    const user = await res.json();
+    return toUserRef2(user);
+  }
+  async fetchPullRequests() {
+    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")
+    ]);
+    const byKey = new Map;
+    const roles = new Map;
+    const addAll = (prs, role) => {
+      for (const pr of prs) {
+        const key = `${pr.base.repo.id}:${pr.number}`;
+        if (!byKey.has(key)) {
+          byKey.set(key, pr);
+          roles.set(key, [role]);
+        } else {
+          const existing = roles.get(key);
+          if (!existing.includes(role))
+            existing.push(role);
+        }
+      }
+    };
+    addAll(authored, "author");
+    addAll(reviewRequested, "reviewer");
+    addAll(assigned, "assignee");
+    const entries = [...byKey.entries()];
+    const results = await Promise.all(entries.map(async ([key, pr]) => {
+      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)
+      ]);
+      return this.toPullRequest(pr, prRoles, reviews, checkRuns);
+    }));
+    this.log.debug("GitHubProvider.fetchPullRequests", { count: results.length });
+    return results;
+  }
+  async fetchSingleMR(projectPath, mrIid, _currentUserNumericId) {
+    try {
+      const res = await this.api("GET", `/repos/${projectPath}/pulls/${mrIid}`);
+      if (!res.ok)
+        return null;
+      const pr = await res.json();
+      const [reviews, checkRuns] = await Promise.all([
+        this.fetchReviews(projectPath, mrIid),
+        this.fetchCheckRuns(projectPath, pr.head.sha)
+      ]);
+      const currentUser = await this.api("GET", "/user");
+      const currentUserData = await currentUser.json();
+      const prRoles = [];
+      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"], reviews, checkRuns);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.warn("GitHubProvider.fetchSingleMR failed", {
+        projectPath,
+        mrIid,
+        message
+      });
+      return null;
+    }
+  }
+  async fetchMRDiscussions(repositoryId, mrIid) {
+    const repoId = parseInt(repositoryId.split(":").pop() ?? "0", 10);
+    const repoRes = await this.api("GET", `/repositories/${repoId}`);
+    if (!repoRes.ok) {
+      throw new Error(`Failed to fetch repo: ${repoRes.status}`);
+    }
+    const repo = await repoRes.json();
+    const [reviewComments, issueComments] = await Promise.all([
+      this.fetchAllPages(`/repos/${repo.full_name}/pulls/${mrIid}/comments?per_page=100`),
+      this.fetchAllPages(`/repos/${repo.full_name}/issues/${mrIid}/comments?per_page=100`)
+    ]);
+    const discussions = [];
+    for (const c of issueComments) {
+      discussions.push({
+        id: `gh-issue-comment-${c.id}`,
+        resolvable: null,
+        resolved: null,
+        notes: [toNote2(c)]
+      });
+    }
+    const threadMap = new Map;
+    for (const c of reviewComments) {
+      const rootId = c.in_reply_to_id ?? c.id;
+      const thread = threadMap.get(rootId) ?? [];
+      thread.push(c);
+      threadMap.set(rootId, thread);
+    }
+    for (const [rootId, comments] of threadMap) {
+      comments.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+      discussions.push({
+        id: `gh-review-thread-${rootId}`,
+        resolvable: true,
+        resolved: null,
+        notes: comments.map(toNote2)
+      });
+    }
+    return { mrIid, repositoryId, discussions };
+  }
+  async restRequest(method, path, body) {
+    return this.api(method, path, body);
+  }
+  async api(method, path, body) {
+    const url = `${this.apiBase}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    };
+    if (body !== undefined) {
+      headers["Content-Type"] = "application/json";
+    }
+    return fetch(url, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+  }
+  async searchPRs(qualifiers) {
+    const q = encodeURIComponent(qualifiers);
+    const res = await this.api("GET", `/search/issues?q=${q}&per_page=100&sort=updated`);
+    if (!res.ok) {
+      this.log.warn("GitHub search failed", { status: res.status, qualifiers });
+      return [];
+    }
+    const data = await res.json();
+    const prPromises = data.items.filter((item) => item.pull_request).map(async (item) => {
+      const repoPath = item.repository_url.replace(`${this.apiBase}/repos/`, "");
+      const res2 = await this.api("GET", `/repos/${repoPath}/pulls/${item.number}`);
+      if (!res2.ok)
+        return null;
+      return await res2.json();
+    });
+    const results = await Promise.all(prPromises);
+    return results.filter((pr) => pr !== null);
+  }
+  async fetchReviews(repoPath, prNumber) {
+    return this.fetchAllPages(`/repos/${repoPath}/pulls/${prNumber}/reviews?per_page=100`);
+  }
+  async fetchCheckRuns(repoPath, sha) {
+    try {
+      const res = await this.api("GET", `/repos/${repoPath}/commits/${sha}/check-runs?per_page=100`);
+      if (!res.ok)
+        return [];
+      const data = await res.json();
+      return data.check_runs;
+    } catch {
+      return [];
+    }
+  }
+  async fetchAllPages(path) {
+    const results = [];
+    let url = path;
+    while (url) {
+      const res = await this.api("GET", url);
+      if (!res.ok)
+        break;
+      const items = await res.json();
+      results.push(...items);
+      const linkHeader = res.headers.get("Link");
+      const nextMatch = linkHeader?.match(/<([^>]+)>;\s*rel="next"/);
+      if (nextMatch) {
+        url = nextMatch[1].replace(this.apiBase, "");
+      } else {
+        url = null;
+      }
+    }
+    return results;
+  }
+  toPullRequest(pr, roles, reviews, checkRuns) {
+    const latestReviewByUser = new Map;
+    for (const r of reviews.sort((a, b) => new Date(a.submitted_at).getTime() - new Date(b.submitted_at).getTime())) {
+      latestReviewByUser.set(r.user.id, r);
+    }
+    const approvedBy = [];
+    let changesRequested = 0;
+    for (const r of latestReviewByUser.values()) {
+      if (r.state === "APPROVED") {
+        approvedBy.push(toUserRef2(r.user));
+      } else if (r.state === "CHANGES_REQUESTED") {
+        changesRequested++;
+      }
+    }
+    const approvalsLeft = changesRequested;
+    const diffStats = pr.additions !== undefined ? {
+      additions: pr.additions,
+      deletions: pr.deletions ?? 0,
+      filesChanged: pr.changed_files ?? 0
+    } : null;
+    const conflicts = pr.mergeable === false || pr.mergeable_state === "dirty";
+    const pipeline = toPipeline2(checkRuns, pr.html_url);
+    return {
+      id: `github:pr:${pr.id}`,
+      iid: pr.number,
+      repositoryId: `github:${pr.base.repo.id}`,
+      title: pr.title,
+      state: normalizePRState(pr),
+      draft: pr.draft,
+      conflicts,
+      webUrl: pr.html_url,
+      sourceBranch: pr.head.ref,
+      targetBranch: pr.base.ref,
+      createdAt: pr.created_at,
+      updatedAt: pr.updated_at,
+      sha: pr.head.sha,
+      author: toUserRef2(pr.user),
+      assignees: pr.assignees.map(toUserRef2),
+      reviewers: pr.requested_reviewers.map(toUserRef2),
+      roles,
+      pipeline,
+      description: pr.body ?? null,
+      unresolvedThreadCount: 0,
+      approvalsLeft,
+      approved: approvedBy.length > 0 && changesRequested === 0,
+      approvedBy,
+      diffStats,
+      detailedMergeStatus: null
+    };
+  }
+}
+function toNote2(c) {
+  const position = c.path ? {
+    newPath: c.path,
+    oldPath: c.path,
+    newLine: c.line ?? null,
+    oldLine: c.original_line ?? null,
+    positionType: c.path ? "text" : null
+  } : null;
+  return {
+    id: c.id,
+    body: c.body,
+    author: toNoteAuthor(c.user),
+    createdAt: c.created_at,
+    system: false,
+    type: c.path ? "DiffNote" : "DiscussionNote",
+    resolvable: c.path ? true : null,
+    resolved: null,
+    position
+  };
+}
+function toNoteAuthor(u) {
+  return {
+    id: `github:user:${u.id}`,
+    username: u.login,
+    name: u.name ?? u.login,
+    avatarUrl: u.avatar_url
+  };
+}
+
+// src/providers.ts
+function createProvider(provider, baseURL, token, options = {}) {
+  switch (provider) {
+    case "gitlab":
+      return new GitLabProvider(baseURL, token, options);
+    case "github":
+      return new GitHubProvider(baseURL, token, options);
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+var SUPPORTED_PROVIDERS = ["gitlab", "github"];
+
+// src/ActionCableClient.ts
+var BASE_RECONNECT_DELAY_MS = 1000;
+var MAX_RECONNECT_DELAY_MS = 120000;
+var MAX_RECONNECT_ATTEMPTS = 8;
+
+class ActionCableClient {
+  token;
+  callbacks;
+  ws = null;
+  reconnectAttempt = 0;
+  intentionalDisconnect = false;
+  reconnectTimer = null;
+  wsUrl;
+  originUrl;
+  log;
+  logContext;
+  constructor(baseURL, token, callbacks, options = {}) {
+    this.token = token;
+    this.callbacks = callbacks;
+    this.log = options.logger ?? noopLogger;
+    this.logContext = options.logContext ?? "";
+    const stripped = baseURL.replace(/\/$/, "");
+    this.originUrl = stripped;
+    this.wsUrl = stripped.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://") + "/-/cable";
+  }
+  connect() {
+    this.intentionalDisconnect = false;
+    this.reconnectAttempt = 0;
+    this.performConnect();
+  }
+  disconnect() {
+    this.intentionalDisconnect = true;
+    this.cleanup();
+    this.log.info("ActionCable intentionally disconnected", {
+      url: this.wsUrl,
+      ctx: this.logContext
+    });
+  }
+  subscribe(identifier) {
+    this.send({ command: "subscribe", identifier });
+  }
+  unsubscribe(identifier) {
+    this.send({ command: "unsubscribe", identifier });
+  }
+  performConnect() {
+    this.cleanup();
+    let ws;
+    try {
+      ws = new WebSocket(this.wsUrl, {
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          Origin: this.originUrl
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.log.error("ActionCable failed to create WebSocket", {
+        url: this.wsUrl,
+        message,
+        ctx: this.logContext
+      });
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.onmessage = (event) => {
+      const raw = typeof event.data === "string" ? event.data : String(event.data);
+      this.handleMessage(raw);
+    };
+    ws.onclose = (event) => {
+      if (this.intentionalDisconnect) {
+        this.callbacks.onDisconnected(true, "intentional disconnect");
+      } else {
+        const reason = event.reason || `code ${event.code}`;
+        this.log.warn("ActionCable disconnected", {
+          url: this.wsUrl,
+          reason,
+          ctx: this.logContext
+        });
+        this.callbacks.onDisconnected(false, reason);
+        this.scheduleReconnect();
+      }
+    };
+    ws.onerror = () => {
+      this.log.warn("ActionCable WebSocket error", { url: this.wsUrl, ctx: this.logContext });
+    };
+    this.log.info("ActionCable connecting", { url: this.wsUrl, ctx: this.logContext });
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!msg.type) {
+      if (typeof msg.identifier === "string" && msg.message !== undefined) {
+        this.callbacks.onMessage(msg.identifier, msg.message);
+      }
+      return;
+    }
+    switch (msg.type) {
+      case "welcome":
+        this.reconnectAttempt = 0;
+        this.log.info("ActionCable connected (welcome)", { url: this.wsUrl, ctx: this.logContext });
+        this.callbacks.onConnected();
+        break;
+      case "ping":
+        break;
+      case "confirm_subscription":
+        if (typeof msg.identifier === "string") {
+          this.log.debug("ActionCable subscription confirmed", { ctx: this.logContext });
+          this.callbacks.onConfirm(msg.identifier);
+        }
+        break;
+      case "reject_subscription":
+        if (typeof msg.identifier === "string") {
+          this.log.warn("ActionCable subscription rejected", { ctx: this.logContext });
+          this.callbacks.onReject(msg.identifier);
+        }
+        break;
+      case "disconnect": {
+        const shouldReconnect = msg.reconnect !== false;
+        this.log.info("ActionCable server disconnect", {
+          reason: msg.reason,
+          reconnect: shouldReconnect,
+          ctx: this.logContext
+        });
+        if (!shouldReconnect)
+          this.intentionalDisconnect = true;
+        this.callbacks.onDisconnected(!shouldReconnect, msg.reason ?? "server disconnect");
+        break;
+      }
+    }
+  }
+  send(obj) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(obj));
+    }
+  }
+  cleanup() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws !== null) {
+      this.ws.onmessage = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempt >= MAX_RECONNECT_ATTEMPTS) {
+      this.log.error("ActionCable max reconnect attempts reached", {
+        url: this.wsUrl,
+        ctx: this.logContext
+      });
+      return;
+    }
+    const base = BASE_RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempt);
+    const jitter = Math.random() * base * 0.3;
+    const delayMs = Math.min(base + jitter, MAX_RECONNECT_DELAY_MS);
+    this.reconnectAttempt++;
+    this.log.info("ActionCable scheduling reconnect", {
+      attempt: this.reconnectAttempt,
+      delayMs: Math.round(delayMs),
+      ctx: this.logContext
+    });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (!this.intentionalDisconnect) {
+        this.performConnect();
+      }
+    }, delayMs);
+  }
+}
+
+// src/NoteMutator.ts
+class NoteMutator {
+  baseURL;
+  token;
+  constructor(baseURL, token) {
+    this.baseURL = baseURL.replace(/\/$/, "");
+    this.token = token;
+  }
+  async createNote(projectId, mrIid, body, discussionId) {
+    const url = discussionId ? `${this.baseURL}/api/v4/projects/${projectId}/merge_requests/${mrIid}/discussions/${discussionId}/notes` : `${this.baseURL}/api/v4/projects/${projectId}/merge_requests/${mrIid}/notes`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PRIVATE-TOKEN": this.token
+      },
+      body: JSON.stringify({ body })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`createNote failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ""}`);
+    }
+    return await res.json();
+  }
+  async updateNote(projectId, mrIid, noteId, body) {
+    const url = `${this.baseURL}/api/v4/projects/${projectId}/merge_requests/${mrIid}/notes/${noteId}`;
+    const res = await fetch(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        "PRIVATE-TOKEN": this.token
+      },
+      body: JSON.stringify({ body })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`updateNote failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ""}`);
+    }
+  }
+  async deleteNote(projectId, mrIid, noteId) {
+    const url = `${this.baseURL}/api/v4/projects/${projectId}/merge_requests/${mrIid}/notes/${noteId}`;
+    const res = await fetch(url, {
+      method: "DELETE",
+      headers: { "PRIVATE-TOKEN": this.token }
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`deleteNote failed: ${res.status} ${res.statusText}${text ? ` — ${text}` : ""}`);
+    }
+  }
+}
+export {
+  repoIdProvider,
+  parseRepoId,
+  parseGitLabRepoId,
+  noopLogger,
+  createProvider,
+  SUPPORTED_PROVIDERS,
+  NoteMutator,
+  MR_DASHBOARD_FRAGMENT,
+  MRDetailFetcher,
+  GitLabProvider,
+  GitHubProvider,
+  ActionCableClient
+};