@colrealpro/react-luau-doctor 0.17.2 → 0.17.3

package/dist/cli.js

@@ -11,7 +11,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.17.2",
+  version: "0.17.3",
   description: "Static analysis for React-Luau hooks, effects, rendering, and performance.",
   license: "MIT",
   type: "module",
@@ -164,6 +164,7 @@ function normalizeCategory(value) {
 
 // src/ci.ts
 import { spawnSync as spawnSync2 } from "child_process";
+import { createHash } from "crypto";
 import fs9 from "fs";
 import path11 from "path";
 import readline from "readline/promises";
@@ -9014,6 +9015,9 @@ var GITLAB_WORKFLOW = ".gitlab-ci.yml";
 var SUMMARY_MARKER = "<!-- react-luau-doctor:summary -->";
 var REVIEW_MARKER = "<!-- react-luau-doctor:review -->";
 var MAX_REVIEW_COMMENTS = 20;
+var MAX_RESOLVE_THREADS_PER_REQUEST = 100;
+var MAX_GITHUB_RETRIES = 2;
+var MAX_RATE_LIMIT_WAIT_MS = 60000;
 var PACKAGE_SPEC = `${package_default.name}@${package_default.version}`;
 function yamlString(value) {
   return JSON.stringify(value);
@@ -9337,6 +9341,15 @@ async function scanForCi(settings, eventName, base) {
   }
   return roots.length === 1 && roots[0] === directory ? reports[0].report : aggregateReports(directory, reports);
 }
+async function findNewReviewDiagnostics(settings, eventName, event, currentReport) {
+  if (event.action === "synchronize" && event.before) {
+    const report = await scanForCi({ ...settings, scope: "changed" }, eventName, event.before);
+    return { diagnostics: report.diagnostics, base: event.before };
+  }
+  if (event.action && event.action !== "opened")
+    return { diagnostics: [] };
+  return { diagnostics: currentReport.diagnostics };
+}
 function shouldBlock(report, level) {
   if (level === "none")
     return false;
@@ -9369,27 +9382,82 @@ function githubRunUrl() {
   const runId = process.env.GITHUB_RUN_ID;
   return server && repository && runId ? `${server}/${repository}/actions/runs/${runId}` : null;
 }
-async function githubApi(repo, endpoint, options = {}) {
+function wait(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function githubRetryDelay(response, responseText, attempt) {
+  const remaining = response.headers.get("x-ratelimit-remaining");
+  const rateLimited = response.status === 429 || response.status === 403 && (remaining === "0" || /rate limit|rate_limit|abuse detection/i.test(responseText)) || response.status === 200 && /"errors"\s*:/.test(responseText) && /rate limit|rate_limit/i.test(responseText);
+  if (!rateLimited)
+    return null;
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0)
+      return seconds * 1000;
+    const date = Date.parse(retryAfter);
+    if (Number.isFinite(date))
+      return Math.max(0, date - Date.now());
+  }
+  if (remaining === "0") {
+    const reset = Number(response.headers.get("x-ratelimit-reset"));
+    if (Number.isFinite(reset))
+      return Math.max(0, reset * 1000 - Date.now() + 1000);
+  }
+  return 60000 * 2 ** attempt;
+}
+async function githubRequest(url, options = {}) {
   const token = process.env.GITHUB_TOKEN;
   if (!token)
     throw new Error("GITHUB_TOKEN is unavailable");
-  const apiBase = process.env.GITHUB_API_URL ?? "https://api.github.com";
-  const response = await fetch(`${apiBase}/repos/${repo}${endpoint}`, {
-    method: options.method ?? "GET",
-    headers: {
-      Accept: "application/vnd.github+json",
-      Authorization: `Bearer ${token}`,
-      "X-GitHub-Api-Version": "2022-11-28",
-      "User-Agent": "react-luau-doctor",
-      "Content-Type": "application/json"
-    },
-    body: options.body === undefined ? undefined : JSON.stringify(options.body)
+  for (let attempt = 0;; attempt += 1) {
+    const response = await fetch(url, {
+      method: options.method ?? "GET",
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${token}`,
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "react-luau-doctor",
+        "Content-Type": "application/json"
+      },
+      body: options.body === undefined ? undefined : JSON.stringify(options.body)
+    });
+    const responseText = response.status === 204 ? "" : await response.text();
+    const delay = githubRetryDelay(response, responseText, attempt);
+    if (response.ok && delay === null)
+      return responseText ? JSON.parse(responseText) : undefined;
+    if (delay === null || attempt >= MAX_GITHUB_RETRIES || delay > MAX_RATE_LIMIT_WAIT_MS) {
+      const retryDetail = delay !== null && delay > MAX_RATE_LIMIT_WAIT_MS ? ` Retry after ${Math.ceil(delay / 1000)} seconds.` : "";
+      throw new Error(`GitHub API ${response.status}: ${responseText}${retryDetail}`);
+    }
+    process.stderr.write(`react-luau-doctor: GitHub API ${response.status}; retrying in ${Math.ceil(delay / 1000)} seconds
+`);
+    await wait(delay);
+  }
+}
+async function githubApi(repo, endpoint, options = {}) {
+  const apiBase = (process.env.GITHUB_API_URL ?? "https://api.github.com").replace(/\/$/, "");
+  return githubRequest(`${apiBase}/repos/${repo}${endpoint}`, options);
+}
+function githubGraphQLUrl() {
+  if (process.env.GITHUB_GRAPHQL_URL)
+    return process.env.GITHUB_GRAPHQL_URL;
+  const apiBase = (process.env.GITHUB_API_URL ?? "https://api.github.com").replace(/\/$/, "");
+  return apiBase.endsWith("/api/v3") ? `${apiBase.slice(0, -3)}graphql` : `${apiBase}/graphql`;
+}
+async function githubGraphQL(query, variables) {
+  const response = await githubRequest(githubGraphQLUrl(), {
+    method: "POST",
+    body: { query, variables }
   });
-  if (!response.ok)
-    throw new Error(`GitHub API ${response.status}: ${await response.text()}`);
-  if (response.status === 204)
-    return;
-  return await response.json();
+  if (response.errors?.length)
+    throw new Error(`GitHub GraphQL: ${response.errors.map((error) => error.message ?? "unknown error").join("; ")}`);
+  if (!response.data)
+    throw new Error("GitHub GraphQL returned no data");
+  return response.data;
 }
 function repoRelativeDiagnosticPath(directory, diagnosticFile) {
   const absoluteDirectory = path11.resolve(directory);
@@ -9477,34 +9545,145 @@ function changedLineMap(directory, base) {
 function touchesChangedLine(diagnostic, ranges) {
   return ranges.some((range) => diagnostic.location.line >= range.start && diagnostic.location.line <= range.end);
 }
-async function replaceReviewComments(repo, pullNumber, report, directory, base) {
-  const lineMap = changedLineMap(directory, base);
-  const comments = report.diagnostics.filter((diagnostic) => touchesChangedLine(diagnostic, lineMap.get(diagnostic.file) ?? [])).slice(0, MAX_REVIEW_COMMENTS).map((diagnostic) => ({
-    path: repoRelativeDiagnosticPath(directory, diagnostic.file),
-    line: diagnostic.location.line,
-    side: "RIGHT",
-    body: `${REVIEW_MARKER}
+function reviewFingerprint(pathname, rule, severity, message) {
+  return createHash("sha256").update(`${pathname}\x00${rule}\x00${severity}\x00${message}`).digest("hex").slice(0, 32);
+}
+function diagnosticReviewFingerprint(directory, diagnostic) {
+  return reviewFingerprint(repoRelativeDiagnosticPath(directory, diagnostic.file), diagnostic.rule, diagnostic.severity, diagnostic.message);
+}
+function fingerprintFromReviewBody(body, pathname) {
+  const marker = body.match(/<!-- react-luau-doctor:fingerprint:([a-f0-9]{32}) -->/i);
+  if (marker)
+    return marker[1].toLowerCase();
+  const legacy = body.match(/\*\*React-Luau Doctor\*\* \u00B7 `([^`]+)` \((error|warning|suggestion)\)\n\n([^\n]+)/);
+  return legacy ? reviewFingerprint(pathname, legacy[1], legacy[2], legacy[3]) : null;
+}
+function reviewCommentBody(directory, diagnostic) {
+  const fingerprint = diagnosticReviewFingerprint(directory, diagnostic);
+  return `${REVIEW_MARKER}
+<!-- react-luau-doctor:fingerprint:${fingerprint} -->
 **React-Luau Doctor** \xB7 \`${diagnostic.rule}\` (${diagnostic.severity})
 
 ${diagnostic.message}${diagnostic.help ? `
 
-${diagnostic.help}` : ""}`
+${diagnostic.help}` : ""}`;
+}
+async function listReviewThreads(repo, pullNumber) {
+  const separator = repo.indexOf("/");
+  if (separator < 1 || separator === repo.length - 1)
+    throw new Error(`Invalid GitHub repository name: ${repo}`);
+  const owner = repo.slice(0, separator);
+  const name = repo.slice(separator + 1);
+  const threads = [];
+  let cursor = null;
+  for (;; ) {
+    const data = await githubGraphQL(`
+      query DoctorReviewThreads($owner: String!, $name: String!, $pull: Int!, $cursor: String) {
+        repository(owner: $owner, name: $name) {
+          pullRequest(number: $pull) {
+            reviewThreads(first: 100, after: $cursor) {
+              nodes {
+                id
+                isResolved
+                viewerCanResolve
+                path
+                comments(first: 1) {
+                  nodes {
+                    body
+                    author { __typename }
+                  }
+                }
+              }
+              pageInfo { hasNextPage endCursor }
+            }
+          }
+        }
+      }
+    `, { owner, name, pull: pullNumber, cursor });
+    const connection = data.repository?.pullRequest?.reviewThreads;
+    if (!connection)
+      throw new Error(`Could not load review threads for pull request ${pullNumber}`);
+    threads.push(...connection.nodes);
+    if (!connection.pageInfo.hasNextPage)
+      return threads;
+    cursor = connection.pageInfo.endCursor;
+    if (!cursor)
+      throw new Error("GitHub review thread pagination returned no cursor");
+  }
+}
+function doctorThreadFingerprint(thread) {
+  const comment = thread.comments.nodes[0];
+  if (comment?.author?.__typename !== "Bot" || !comment.body.startsWith(REVIEW_MARKER))
+    return null;
+  return fingerprintFromReviewBody(comment.body, thread.path);
+}
+function takeCount(counts, key) {
+  const count = counts.get(key) ?? 0;
+  if (count === 0)
+    return false;
+  counts.set(key, count - 1);
+  return true;
+}
+async function resolveReviewThreads(threadIds) {
+  for (let offset = 0;offset < threadIds.length; offset += MAX_RESOLVE_THREADS_PER_REQUEST) {
+    const batch = threadIds.slice(offset, offset + MAX_RESOLVE_THREADS_PER_REQUEST);
+    const declarations = batch.map((_, index) => `$thread${index}: ID!`).join(", ");
+    const mutations = batch.map((_, index) => `thread${index}: resolveReviewThread(input: { threadId: $thread${index} }) { thread { id isResolved } }`).join(`
+`);
+    const variables = Object.fromEntries(batch.map((id, index) => [`thread${index}`, id]));
+    await githubGraphQL(`mutation ResolveDoctorThreads(${declarations}) { ${mutations} }`, variables);
+    if (offset + batch.length < threadIds.length)
+      await wait(1000);
+  }
+}
+async function manageReviewComments(repo, pullNumber, currentReport, newDiagnostics, directory, newBase) {
+  const threads = await listReviewThreads(repo, pullNumber);
+  const activeCounts = new Map;
+  for (const diagnostic of currentReport.diagnostics) {
+    const fingerprint = diagnosticReviewFingerprint(directory, diagnostic);
+    activeCounts.set(fingerprint, (activeCounts.get(fingerprint) ?? 0) + 1);
+  }
+  const resolvedThreadIds = [];
+  for (const thread of threads) {
+    if (thread.isResolved)
+      continue;
+    const fingerprint = doctorThreadFingerprint(thread);
+    if (!fingerprint)
+      continue;
+    if (!takeCount(activeCounts, fingerprint) && thread.viewerCanResolve) {
+      resolvedThreadIds.push(thread.id);
+    }
+  }
+  const lineMap = changedLineMap(directory, newBase);
+  const comments = newDiagnostics.filter((diagnostic) => touchesChangedLine(diagnostic, lineMap.get(diagnostic.file) ?? [])).filter((diagnostic) => {
+    const fingerprint = diagnosticReviewFingerprint(directory, diagnostic);
+    return takeCount(activeCounts, fingerprint);
+  }).slice(0, MAX_REVIEW_COMMENTS).map((diagnostic) => ({
+    path: repoRelativeDiagnosticPath(directory, diagnostic.file),
+    line: diagnostic.location.line,
+    side: "RIGHT",
+    body: reviewCommentBody(directory, diagnostic)
   }));
-  const previous = await listComments(repo, `/pulls/${pullNumber}/comments`);
+  const failures = [];
   if (comments.length > 0) {
-    await githubApi(repo, `/pulls/${pullNumber}/reviews`, {
-      method: "POST",
-      body: { event: "COMMENT", body: "React-Luau Doctor review", comments }
-    });
+    try {
+      await githubApi(repo, `/pulls/${pullNumber}/reviews`, {
+        method: "POST",
+        body: { event: "COMMENT", body: "React-Luau Doctor found new issues", comments }
+      });
+    } catch (error) {
+      failures.push(`could not create new review comments: ${errorMessage(error)}`);
+    }
   }
-  for (const comment of previous.filter((entry) => isDoctorComment(entry, REVIEW_MARKER))) {
+  if (resolvedThreadIds.length > 0) {
     try {
-      await githubApi(repo, `/pulls/comments/${comment.id}`, { method: "DELETE" });
+      await resolveReviewThreads(resolvedThreadIds);
     } catch (error) {
-      process.stderr.write(`react-luau-doctor: could not remove an earlier review comment: ${error instanceof Error ? error.message : String(error)}
-`);
+      failures.push(`could not resolve fixed review threads: ${errorMessage(error)}`);
     }
   }
+  if (failures.length > 0)
+    throw new Error(failures.join("; "));
 }
 async function publishCommitStatus(repo, sha, report, blocking) {
   const blocked = shouldBlock(report, blocking);
@@ -9563,6 +9742,7 @@ async function runCiJob(argv) {
   const base = isPullRequest ? event.pull_request.base.sha : undefined;
   const head = isPullRequest ? event.pull_request.head.sha : process.env.GITHUB_SHA ?? "HEAD";
   const report = await scanForCi(settings, eventName, base);
+  const reviewChanges = isPullRequest ? await findNewReviewDiagnostics(settings, eventName, event, report) : { diagnostics: [] };
   const fixed = isPullRequest && base ? (await Promise.all(resolveCiProjectRoots(path11.resolve(settings.directory), settings.project).map((root) => fixedIssueCount(root, base)))).reduce((sum, count) => sum + count, 0) : 0;
   const skipped = isPullRequest && report.scannedFiles === 0 && fixed === 0;
   const effectiveBlocking = isPullRequest ? settings.blocking : "none";
@@ -9585,15 +9765,15 @@ async function runCiJob(argv) {
       try {
         await updateStickyComment(repo, pullNumber, renderSummaryComment(report, repo, head, fixed, skipped, settings.directory), !skipped);
       } catch (error) {
-        process.stderr.write(`react-luau-doctor: could not update the sticky PR comment: ${error instanceof Error ? error.message : String(error)}
+        process.stderr.write(`react-luau-doctor: could not update the sticky PR comment: ${errorMessage(error)}
 `);
       }
     }
     if (settings.reviewComments && base) {
       try {
-        await replaceReviewComments(repo, pullNumber, report, path11.resolve(settings.directory), base);
+        await manageReviewComments(repo, pullNumber, report, reviewChanges.diagnostics, path11.resolve(settings.directory), reviewChanges.base ?? base);
       } catch (error) {
-        process.stderr.write(`react-luau-doctor: could not update inline review comments: ${error instanceof Error ? error.message : String(error)}
+        process.stderr.write(`react-luau-doctor: could not update inline review comments: ${errorMessage(error)}
 `);
       }
     }
@@ -9602,7 +9782,7 @@ async function runCiJob(argv) {
     try {
       await publishCommitStatus(repo, head, report, effectiveBlocking);
     } catch (error) {
-      process.stderr.write(`react-luau-doctor: could not publish the commit status: ${error instanceof Error ? error.message : String(error)}
+      process.stderr.write(`react-luau-doctor: could not publish the commit status: ${errorMessage(error)}
 `);
     }
   }
@@ -11398,5 +11578,5 @@ ${os2.release()}
 }
 main();
 
-//# debugId=5A3899945A5E839764756E2164756E21
+//# debugId=0C8033468B7931C864756E2164756E21
 //# sourceMappingURL=cli.js.map