@colrealpro/react-luau-doctor 0.18.0 → 0.18.2

package/dist/cli.js

@@ -2,16 +2,16 @@
 // @bun
 
 // src/cli.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import os2 from "os";
-import path12 from "path";
+import path13 from "path";
 // package.json
 var package_default = {
   name: "@colrealpro/react-luau-doctor",
   publishConfig: {
     access: "public"
   },
-  version: "0.18.0",
+  version: "0.18.2",
   description: "Static analysis for React-Luau hooks, effects, rendering, and performance.",
   license: "MIT",
   type: "module",
@@ -9904,7 +9904,6 @@ 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}`;
@@ -9920,10 +9919,8 @@ on:
     branches: [main]
 
 permissions:
-  # GitHub currently requires Contents: write for the resolveReviewThread GraphQL mutation.
-  contents: ${settings.reviewComments ? "write" : "read"}
+  contents: read
   pull-requests: write
-  issues: write
   statuses: write
 
 concurrency:
@@ -10332,23 +10329,6 @@ 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, -"/v3".length)}/graphql` : `${apiBase}/graphql`;
-}
-async function githubGraphQL(query, variables) {
-  const response = await githubRequest(githubGraphQLUrl(), {
-    method: "POST",
-    body: { query, variables }
-  });
-  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);
   const repoRoot = findGitRoot(absoluteDirectory);
@@ -10458,54 +10438,32 @@ ${diagnostic.message}${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
-                isOutdated
-                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))
+var ARCHIVED_REVIEW_BODY = "\u2705 React-Luau Doctor: findings from this review are no longer current. Active findings, if any, are shown in newer reviews.";
+async function listReviewComments(repo, pullNumber) {
+  const comments = [];
+  for (let page = 1;; page += 1) {
+    const batch = await githubApi(repo, `/pulls/${pullNumber}/comments?per_page=100&page=${page}`);
+    comments.push(...batch);
+    if (batch.length < 100)
+      return comments;
+  }
+}
+async function listReviews(repo, pullNumber) {
+  const reviews = [];
+  for (let page = 1;; page += 1) {
+    const batch = await githubApi(repo, `/pulls/${pullNumber}/reviews?per_page=100&page=${page}`);
+    reviews.push(...batch);
+    if (batch.length < 100)
+      return reviews;
+  }
+}
+function isDoctorReview(review) {
+  return review.user?.type === "Bot" && (review.body?.includes("React-Luau Doctor") ?? false);
+}
+function doctorReviewCommentFingerprint(comment) {
+  if (comment.user?.type !== "Bot" || !comment.body.startsWith(REVIEW_MARKER))
     return null;
-  return fingerprintFromReviewBody(comment.body, thread.path);
+  return fingerprintFromReviewBody(comment.body, comment.path);
 }
 function takeCount(counts, key) {
   const count = counts.get(key) ?? 0;
@@ -10514,58 +10472,64 @@ function takeCount(counts, key) {
   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);
-  }
+function incrementCount(counts, key) {
+  counts.set(key, (counts.get(key) ?? 0) + 1);
 }
-async function manageReviewComments(repo, pullNumber, currentReport, newDiagnostics, directory, newBase) {
-  const threads = await listReviewThreads(repo, pullNumber);
+async function manageReviewComments(repo, pullNumber, currentReport, newDiagnostics, directory, newBase, pullBase) {
+  const [allReviewComments, reviews] = await Promise.all([
+    listReviewComments(repo, pullNumber),
+    listReviews(repo, pullNumber)
+  ]);
+  const reviewComments = allReviewComments.map((comment) => ({ comment, fingerprint: doctorReviewCommentFingerprint(comment) })).filter((entry) => entry.fingerprint !== null);
   const activeCounts = new Map;
-  for (const diagnostic of currentReport.diagnostics) {
-    const fingerprint = diagnosticReviewFingerprint(directory, diagnostic);
-    activeCounts.set(fingerprint, (activeCounts.get(fingerprint) ?? 0) + 1);
-  }
+  for (const diagnostic of currentReport.diagnostics)
+    incrementCount(activeCounts, diagnosticReviewFingerprint(directory, diagnostic));
   const newCounts = new Map;
-  for (const diagnostic of newDiagnostics) {
-    const fingerprint = diagnosticReviewFingerprint(directory, diagnostic);
-    newCounts.set(fingerprint, (newCounts.get(fingerprint) ?? 0) + 1);
-  }
-  const resolvedThreadIds = [];
-  for (const thread of threads) {
-    if (thread.isResolved)
-      continue;
-    const fingerprint = doctorThreadFingerprint(thread);
-    if (!fingerprint)
-      continue;
-    if (thread.isOutdated && (newCounts.get(fingerprint) ?? 0) > 0) {
-      resolvedThreadIds.push(thread.id);
+  for (const diagnostic of newDiagnostics)
+    incrementCount(newCounts, diagnosticReviewFingerprint(directory, diagnostic));
+  const replacementCounts = new Map;
+  const staleComments = [];
+  const orderedComments = reviewComments.slice().sort((left, right) => Number(left.comment.position === null) - Number(right.comment.position === null));
+  for (const { comment, fingerprint } of orderedComments) {
+    if (comment.position !== null && takeCount(activeCounts, fingerprint)) {
+      takeCount(newCounts, fingerprint);
       continue;
     }
-    if (takeCount(activeCounts, fingerprint)) {
+    const needsReplacement = takeCount(activeCounts, fingerprint);
+    if (needsReplacement) {
+      incrementCount(replacementCounts, fingerprint);
       takeCount(newCounts, fingerprint);
-      continue;
     }
-    resolvedThreadIds.push(thread.id);
+    staleComments.push({ comment, fingerprint, needsReplacement });
+  }
+  const newLineMap = changedLineMap(directory, newBase);
+  const pullLineMap = newBase === pullBase ? newLineMap : changedLineMap(directory, pullBase);
+  const candidates = [];
+  for (const diagnostic of newDiagnostics) {
+    if (!touchesChangedLine(diagnostic, newLineMap.get(diagnostic.file) ?? []))
+      continue;
+    const fingerprint = diagnosticReviewFingerprint(directory, diagnostic);
+    if (!takeCount(newCounts, fingerprint))
+      continue;
+    candidates.push({ diagnostic, replacement: false });
   }
-  const lineMap = changedLineMap(directory, newBase);
-  const comments = newDiagnostics.filter((diagnostic) => touchesChangedLine(diagnostic, lineMap.get(diagnostic.file) ?? [])).filter((diagnostic) => {
+  for (const diagnostic of currentReport.diagnostics) {
+    if (!touchesChangedLine(diagnostic, pullLineMap.get(diagnostic.file) ?? []))
+      continue;
     const fingerprint = diagnosticReviewFingerprint(directory, diagnostic);
-    return takeCount(newCounts, fingerprint);
-  }).slice(0, MAX_REVIEW_COMMENTS).map((diagnostic) => ({
+    if (!takeCount(replacementCounts, fingerprint))
+      continue;
+    candidates.push({ diagnostic, replacement: true });
+  }
+  const selected = candidates.slice(0, MAX_REVIEW_COMMENTS);
+  const comments = selected.map(({ diagnostic }) => ({
     path: repoRelativeDiagnosticPath(directory, diagnostic.file),
     line: diagnostic.location.line,
     side: "RIGHT",
     body: reviewCommentBody(directory, diagnostic)
   }));
   const failures = [];
+  let postedNewComments = true;
   if (comments.length > 0) {
     try {
       await githubApi(repo, `/pulls/${pullNumber}/reviews`, {
@@ -10573,14 +10537,45 @@ async function manageReviewComments(repo, pullNumber, currentReport, newDiagnost
         body: { event: "COMMENT", body: "React-Luau Doctor found new issues", comments }
       });
     } catch (error) {
+      postedNewComments = false;
       failures.push(`could not create new review comments: ${errorMessage(error)}`);
     }
   }
-  if (resolvedThreadIds.length > 0) {
-    try {
-      await resolveReviewThreads(resolvedThreadIds);
-    } catch (error) {
-      failures.push(`could not resolve fixed review threads: ${errorMessage(error)}`);
+  if (postedNewComments) {
+    const postedReplacementCounts = new Map;
+    for (const candidate of selected) {
+      if (candidate.replacement)
+        incrementCount(postedReplacementCounts, diagnosticReviewFingerprint(directory, candidate.diagnostic));
+    }
+    const remainingByReview = new Map;
+    for (const { comment } of reviewComments) {
+      remainingByReview.set(comment.pull_request_review_id, (remainingByReview.get(comment.pull_request_review_id) ?? 0) + 1);
+    }
+    for (const stale of staleComments) {
+      if (stale.needsReplacement && !takeCount(postedReplacementCounts, stale.fingerprint))
+        continue;
+      try {
+        await githubApi(repo, `/pulls/comments/${stale.comment.id}`, { method: "DELETE" });
+        const reviewId = stale.comment.pull_request_review_id;
+        const remaining = Math.max(0, (remainingByReview.get(reviewId) ?? 1) - 1);
+        remainingByReview.set(reviewId, remaining);
+      } catch (error) {
+        failures.push(`could not delete stale review comment ${stale.comment.id}: ${errorMessage(error)}`);
+      }
+    }
+    for (const review of reviews) {
+      if (!isDoctorReview(review) || review.body === ARCHIVED_REVIEW_BODY)
+        continue;
+      if ((remainingByReview.get(review.id) ?? 0) > 0)
+        continue;
+      try {
+        await githubApi(repo, `/pulls/${pullNumber}/reviews/${review.id}`, {
+          method: "PUT",
+          body: { body: ARCHIVED_REVIEW_BODY }
+        });
+      } catch (error) {
+        failures.push(`could not archive empty review ${review.id}: ${errorMessage(error)}`);
+      }
     }
   }
   if (failures.length > 0)
@@ -10672,7 +10667,7 @@ async function runCiJob(argv) {
     }
     if (settings.reviewComments && base) {
       try {
-        await manageReviewComments(repo, pullNumber, report, reviewChanges.diagnostics, path11.resolve(settings.directory), reviewChanges.base ?? base);
+        await manageReviewComments(repo, pullNumber, report, reviewChanges.diagnostics, path11.resolve(settings.directory), reviewChanges.base ?? base, base);
       } catch (error) {
         process.stderr.write(`react-luau-doctor: could not update inline review comments: ${errorMessage(error)}
 `);
@@ -10703,6 +10698,210 @@ async function runCiCommand(argv) {
   throw new Error("ci requires install, config, or upgrade");
 }
 
+// src/update-check.ts
+import { spawn } from "child_process";
+import fs10 from "fs";
+import path12 from "path";
+var UPDATE_CHECK_INTERVAL_MS = 2 * 60 * 60 * 1000;
+var UPDATE_REQUEST_TIMEOUT_MS = 5000;
+var UPDATE_CACHE_FILENAME = "update-check.json";
+function updateCacheFilename() {
+  return path12.join(cacheBaseDirectory(), UPDATE_CACHE_FILENAME);
+}
+function readUpdateCache() {
+  try {
+    const parsed = JSON.parse(fs10.readFileSync(updateCacheFilename(), "utf8"));
+    if (typeof parsed.checkedAt !== "number" || !Number.isFinite(parsed.checkedAt))
+      return null;
+    if (parsed.latest !== undefined && typeof parsed.latest !== "string")
+      return null;
+    return {
+      checkedAt: parsed.checkedAt,
+      latest: parsed.latest
+    };
+  } catch {
+    return null;
+  }
+}
+function writeUpdateCache(cache) {
+  try {
+    const filename = updateCacheFilename();
+    fs10.mkdirSync(path12.dirname(filename), { recursive: true });
+    fs10.writeFileSync(filename, `${JSON.stringify(cache)}
+`);
+  } catch {}
+}
+function parseVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(value.trim());
+  if (!match)
+    return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4]?.split(".") ?? []
+  };
+}
+function comparePrerelease(left, right) {
+  if (left.length === 0 || right.length === 0) {
+    if (left.length === right.length)
+      return 0;
+    return left.length === 0 ? 1 : -1;
+  }
+  const count = Math.max(left.length, right.length);
+  for (let index = 0;index < count; index += 1) {
+    const leftPart = left[index];
+    const rightPart = right[index];
+    if (leftPart === undefined)
+      return -1;
+    if (rightPart === undefined)
+      return 1;
+    if (leftPart === rightPart)
+      continue;
+    const leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : null;
+    const rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : null;
+    if (leftNumber !== null && rightNumber !== null)
+      return leftNumber < rightNumber ? -1 : 1;
+    if (leftNumber !== null)
+      return -1;
+    if (rightNumber !== null)
+      return 1;
+    return leftPart < rightPart ? -1 : 1;
+  }
+  return 0;
+}
+function compareVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b)
+    return null;
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key])
+      return a[key] < b[key] ? -1 : 1;
+  }
+  return comparePrerelease(a.prerelease, b.prerelease);
+}
+function updateRegistryUrl() {
+  const registry = process.env.REACT_LUAU_DOCTOR_UPDATE_REGISTRY ?? process.env.npm_config_registry ?? process.env.NPM_CONFIG_REGISTRY ?? "https://registry.npmjs.org/";
+  const base = registry.endsWith("/") ? registry : `${registry}/`;
+  return new URL(`${encodeURIComponent(package_default.name)}/latest`, base).toString();
+}
+async function fetchLatestVersion() {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), UPDATE_REQUEST_TIMEOUT_MS);
+  timer.unref?.();
+  try {
+    const response = await fetch(updateRegistryUrl(), {
+      headers: { accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok)
+      throw new Error(`npm registry returned HTTP ${response.status}`);
+    const body = await response.json();
+    if (typeof body.version !== "string" || compareVersions(body.version, body.version) === null) {
+      throw new Error("npm registry returned an invalid package version");
+    }
+    return body.version;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function updateCacheIsStale(now = Date.now()) {
+  const cache = readUpdateCache();
+  return !cache || now - cache.checkedAt >= UPDATE_CHECK_INTERVAL_MS;
+}
+async function refreshUpdateCache(options = {}) {
+  const now = options.now ?? Date.now();
+  try {
+    const latest = await fetchLatestVersion();
+    writeUpdateCache({ checkedAt: now, latest });
+    return latest;
+  } catch (error) {
+    const previous = readUpdateCache();
+    writeUpdateCache({ checkedAt: now, latest: previous?.latest });
+    if (options.silent)
+      return null;
+    throw error;
+  }
+}
+function startBackgroundUpdateRefresh() {
+  if (!updateCacheIsStale())
+    return;
+  const script = process.argv[1];
+  if (!script)
+    return;
+  try {
+    const child2 = spawn(process.execPath, [script, "__update-cache"], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      env: process.env
+    });
+    child2.unref();
+  } catch {}
+}
+function getCachedUpdateNotice(currentVersion) {
+  const cache = readUpdateCache();
+  if (!cache?.latest)
+    return null;
+  const comparison = compareVersions(cache.latest, currentVersion);
+  if (comparison === null || comparison <= 0)
+    return null;
+  return { current: currentVersion, latest: cache.latest };
+}
+async function checkForUpdatesNow(currentVersion) {
+  const latest = await refreshUpdateCache();
+  if (!latest)
+    throw new Error("Could not check npm for updates");
+  const comparison = compareVersions(latest, currentVersion);
+  if (comparison === null)
+    throw new Error(`Could not compare installed version ${currentVersion} with ${latest}`);
+  return { latest, updateAvailable: comparison > 0 };
+}
+
+// src/update-install.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { fileURLToPath } from "url";
+function normalizedPath(filename) {
+  return filename.replaceAll("\\", "/");
+}
+function updateInstallCommandForPath(filename) {
+  const normalized = normalizedPath(filename);
+  const spec = `${package_default.name}@latest`;
+  if (normalized.includes("/.bun/install/global/node_modules/")) {
+    return {
+      manager: "bun",
+      command: "bun",
+      args: ["add", "-g", spec],
+      display: `bun add -g ${spec}`
+    };
+  }
+  if (normalized.includes("/.bun/install/cache/") || normalized.includes("/.npm/_npx/"))
+    return null;
+  if (normalized.includes("/node_modules/")) {
+    return {
+      manager: "npm",
+      command: "npm",
+      args: ["install", "-g", spec],
+      display: `npm install -g ${spec}`
+    };
+  }
+  return null;
+}
+function currentUpdateInstallCommand() {
+  return updateInstallCommandForPath(fileURLToPath(import.meta.url));
+}
+function installLatestVersion(command) {
+  const result = spawnSync3(command.command, command.args, {
+    stdio: "inherit",
+    windowsHide: true
+  });
+  if (result.error)
+    throw result.error;
+  if (result.status !== 0)
+    throw new Error(`${command.display} exited with code ${result.status ?? "unknown"}`);
+}
+
 // src/fix-examples.ts
 var examples = {
   "react-luau/parse-error": {
@@ -11189,6 +11388,7 @@ Usage:
   react-luau-doctor [directory] [options]
   react-luau-doctor ci <install|config|upgrade>
   react-luau-doctor why <file:line>
+  react-luau-doctor update [--check]
   react-luau-doctor rules <command>
 
 Scan options:
@@ -11217,6 +11417,7 @@ Scan options:
   --no-color                             Disable automatic ANSI colors
   --no-cache                             Disable the persistent OS-level analysis cache
   --no-parallel                          Disable parallel file analysis
+  --no-update-check                      Disable the automatic update notice
 
 React-Luau Doctor options:
   --min-severity <level>                 suggestion, warning, or error
@@ -11229,6 +11430,10 @@ CI commands:
   ci upgrade [--provider github|gitlab] [--pr] [-y] [--cwd <cwd>]
   Reporting toggles: --comment/--no-comment, --review-comments/--no-review-comments, --commit-status/--no-commit-status
 
+Update commands:
+  update                                 Update the global installation to the latest release
+  update --check                         Check npm for a newer release without updating
+
 Rules commands:
   rules list [--category <name>] [--configured] [--json]
   rules explain <rule> [--json]
@@ -11241,6 +11446,53 @@ Config:
   react-luau-doctor.config.json
 `;
 }
+function automaticUpdateNoticeEnabled(options, machineReadable) {
+  return !options.noUpdateCheck && !machineReadable && Boolean(process.stdout.isTTY) && !process.env.CI && process.env.NO_UPDATE_NOTIFIER === undefined && process.env.REACT_LUAU_DOCTOR_NO_UPDATE_CHECK === undefined;
+}
+function renderUpdateNotice(current, latest, colorized) {
+  const label = whyPaint(colorized, "Update available:", WHY_ANSI.bold, WHY_ANSI.yellow);
+  const oldVersion = whyPaint(colorized, `v${current}`, WHY_ANSI.dim);
+  const newVersion = whyPaint(colorized, `v${latest}`, WHY_ANSI.bold);
+  return `${label} ${oldVersion} \u2192 ${newVersion}
+Run \`react-luau-doctor update\` to update.`;
+}
+async function runUpdateCommand(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    process.stdout.write(`Usage: react-luau-doctor update [--check]
+`);
+    return;
+  }
+  if (argv.length > 1 || argv.length === 1 && argv[0] !== "--check") {
+    throw new Error("Usage: react-luau-doctor update [--check]");
+  }
+  const result = await checkForUpdatesNow(VERSION2);
+  if (!result.updateAvailable) {
+    process.stdout.write(`React-Luau Doctor v${VERSION2} is up to date.
+`);
+    return;
+  }
+  const colorized = shouldUseColor(false, false);
+  if (argv[0] === "--check") {
+    process.stdout.write(`${renderUpdateNotice(VERSION2, result.latest, colorized)}
+`);
+    return;
+  }
+  const command = currentUpdateInstallCommand();
+  if (!command) {
+    throw new Error(`Could not determine the global package manager for this installation. Run \`npm install -g ${package_default.name}@latest\` manually.`);
+  }
+  const label = whyPaint(colorized, "Updating React-Luau Doctor:", WHY_ANSI.bold, WHY_ANSI.yellow);
+  const oldVersion = whyPaint(colorized, `v${VERSION2}`, WHY_ANSI.dim);
+  const newVersion = whyPaint(colorized, `v${result.latest}`, WHY_ANSI.bold);
+  process.stdout.write(`${label} ${oldVersion} \u2192 ${newVersion}
+Using \`${command.display}\`
+
+`);
+  installLatestVersion(command);
+  process.stdout.write(`
+Updated React-Luau Doctor to v${result.latest}.
+`);
+}
 function splitLongOption(arg) {
   if (!arg.startsWith("--"))
     return { name: arg };
@@ -11646,6 +11898,7 @@ function parseArgs(argv) {
     noColor: false,
     noCache: false,
     noParallel: false,
+    noUpdateCheck: false,
     help: false,
     version: false
   };
@@ -11683,6 +11936,8 @@ function parseArgs(argv) {
       options.noCache = true;
     else if (arg === "--no-parallel")
       options.noParallel = true;
+    else if (arg === "--no-update-check")
+      options.noUpdateCheck = true;
     else if (arg === "--annotations")
       options.annotations = true;
     else if (arg === "--help" || arg === "-h")
@@ -11800,8 +12055,8 @@ function validateModeFlags(options, scope) {
     throw new Error("--annotations cannot be combined with --json or --score");
 }
 function findProjectByName(root, name) {
-  const direct = path12.resolve(root, name);
-  if (fs10.existsSync(direct) && fs10.statSync(direct).isDirectory())
+  const direct = path13.resolve(root, name);
+  if (fs11.existsSync(direct) && fs11.statSync(direct).isDirectory())
     return direct;
   const ignored = new Set([".git", "node_modules", "Packages", "DevPackages", "ServerPackages", "dist", "vendor"]);
   const queue = [{ directory: root, depth: 0 }];
@@ -11810,17 +12065,17 @@ function findProjectByName(root, name) {
     const current = queue.shift();
     if (current.depth >= 3)
       continue;
-    for (const entry of fs10.readdirSync(current.directory, { withFileTypes: true })) {
+    for (const entry of fs11.readdirSync(current.directory, { withFileTypes: true })) {
       if (!entry.isDirectory() || ignored.has(entry.name))
         continue;
-      const absolute = path12.join(current.directory, entry.name);
+      const absolute = path13.join(current.directory, entry.name);
       if (entry.name === name)
         matches.push(absolute);
       queue.push({ directory: absolute, depth: current.depth + 1 });
     }
   }
   if (matches.length > 1)
-    throw new Error(`Project selector "${name}" is ambiguous: ${matches.map((match) => path12.relative(root, match)).join(", ")}`);
+    throw new Error(`Project selector "${name}" is ambiguous: ${matches.map((match) => path13.relative(root, match)).join(", ")}`);
   return matches[0] ?? null;
 }
 function resolveProjectRoots(root, projectFlag, config) {
@@ -11838,15 +12093,15 @@ function serializeReport(report, compact) {
   return compact ? JSON.stringify(report) : JSON.stringify(report, null, 2);
 }
 function writeJsonFile(filename, value, compact = false) {
-  fs10.mkdirSync(path12.dirname(filename), { recursive: true });
-  fs10.writeFileSync(filename, `${compact ? JSON.stringify(value) : JSON.stringify(value, null, 2)}
+  fs11.mkdirSync(path13.dirname(filename), { recursive: true });
+  fs11.writeFileSync(filename, `${compact ? JSON.stringify(value) : JSON.stringify(value, null, 2)}
 `);
 }
 function writeDiagnosticsDump(directory, report) {
-  fs10.mkdirSync(directory, { recursive: true });
-  writeJsonFile(path12.join(directory, "report.json"), report);
-  writeJsonFile(path12.join(directory, "diagnostics.json"), report.diagnostics);
-  writeJsonFile(path12.join(directory, "summary.json"), {
+  fs11.mkdirSync(directory, { recursive: true });
+  writeJsonFile(path13.join(directory, "report.json"), report);
+  writeJsonFile(path13.join(directory, "diagnostics.json"), report.diagnostics);
+  writeJsonFile(path13.join(directory, "summary.json"), {
     schemaVersion: report.schemaVersion,
     root: report.root,
     scope: report.scope ?? "full",
@@ -11882,7 +12137,7 @@ function parseCommandCwd(argv) {
       const value = argv[++index];
       if (!value)
         throw new Error(`${arg} requires a path`);
-      cwd = path12.resolve(value);
+      cwd = path13.resolve(value);
     } else
       remaining.push(arg);
   }
@@ -11991,7 +12246,7 @@ function runRulesCommand(argv) {
     if (!severity)
       throw new Error("Rule severity must be off, suggestion, warning/warn, or error");
     const filename = writeConfig(cwd, (current) => ({ ...current, rules: { ...current.rules, [rule.id]: severity } }));
-    process.stdout.write(`Set ${rule.id} to ${severity} in ${path12.relative(cwd, filename)}
+    process.stdout.write(`Set ${rule.id} to ${severity} in ${path13.relative(cwd, filename)}
 `);
     return;
   }
@@ -12010,7 +12265,7 @@ function runRulesCommand(argv) {
       severity = normalized;
     }
     const filename = writeConfig(cwd, (current) => ({ ...current, rules: { ...current.rules, [rule.id]: severity } }));
-    process.stdout.write(`Enabled ${rule.id} at ${severity} in ${path12.relative(cwd, filename)}
+    process.stdout.write(`Enabled ${rule.id} at ${severity} in ${path13.relative(cwd, filename)}
 `);
     return;
   }
@@ -12020,7 +12275,7 @@ function runRulesCommand(argv) {
       throw new Error("rules disable requires a rule id");
     const rule = findRule(requested);
     const filename = writeConfig(cwd, (current) => ({ ...current, rules: { ...current.rules, [rule.id]: "off" } }));
-    process.stdout.write(`Disabled ${rule.id} in ${path12.relative(cwd, filename)}
+    process.stdout.write(`Disabled ${rule.id} in ${path13.relative(cwd, filename)}
 `);
     return;
   }
@@ -12043,7 +12298,7 @@ function runRulesCommand(argv) {
         ...categoryRules.map((rule) => [rule.id, severity])
       ])
     }));
-    process.stdout.write(`Set ${categoryRules.length} ${category} rules to ${severity} in ${path12.relative(cwd, filename)}
+    process.stdout.write(`Set ${categoryRules.length} ${category} rules to ${severity} in ${path13.relative(cwd, filename)}
 `);
     return;
   }
@@ -12127,7 +12382,7 @@ function whyCaretForLine(sourceLine, line, ranges) {
   return value;
 }
 function renderWhyCodeFrame(filename, diagnostic, colorized) {
-  const source = fs10.readFileSync(filename, "utf8").split(/\r?\n/);
+  const source = fs11.readFileSync(filename, "utf8").split(/\r?\n/);
   const ranges = whyDiagnosticRanges(diagnostic);
   const intervals = whyFrameIntervals(ranges, source.length);
   const width = String(Math.max(...intervals.map((interval) => interval.end), 1)).length;
@@ -12235,13 +12490,13 @@ async function runWhy(location, cwd, noColor = false, cache = true, onProgress,
   const match = location.match(/^(.*):(\d+)(?::(\d+))?$/);
   if (!match)
     throw new Error("Location must be file:line or file:line:column");
-  const filename = path12.resolve(cwd, match[1]);
+  const filename = path13.resolve(cwd, match[1]);
   const line = Number(match[2]);
   const column = match[3] === undefined ? undefined : Number(match[3]);
-  if (!fs10.existsSync(filename))
+  if (!fs11.existsSync(filename))
     throw new Error(`File does not exist: ${match[1]}`);
   const colorized = shouldUseColor(noColor, false);
-  const source = fs10.readFileSync(filename, "utf8");
+  const source = fs11.readFileSync(filename, "utf8");
   const isSuppressed = createInlineSuppressionChecker(source);
   const auditReport = await scanWhyFile(filename, cwd, cache, onProgress);
   beforeOutput?.();
@@ -12282,16 +12537,16 @@ async function runWhy(location, cwd, noColor = false, cache = true, onProgress,
   }
 }
 function pathIsInside(parent, child2) {
-  const relative = path12.relative(parent, child2);
-  return relative === "" || !relative.startsWith("..") && !path12.isAbsolute(relative);
+  const relative = path13.relative(parent, child2);
+  return relative === "" || !relative.startsWith("..") && !path13.isAbsolute(relative);
 }
 async function runScan(options, onProgress) {
   const commandRoot = process.cwd();
-  const target = path12.resolve(commandRoot, options.target);
-  if (!fs10.existsSync(target))
+  const target = path13.resolve(commandRoot, options.target);
+  if (!fs11.existsSync(target))
     throw new Error(`Scan path does not exist: ${options.target}`);
-  const targetStat = fs10.statSync(target);
-  const scanRoot = targetStat.isFile() ? path12.dirname(target) : target;
+  const targetStat = fs11.statSync(target);
+  const scanRoot = targetStat.isFile() ? path13.dirname(target) : target;
   const loaded = loadConfigWithSource(commandRoot);
   const config = loaded.config;
   const resolvedScope = resolveScope(options, config);
@@ -12321,7 +12576,7 @@ async function runScan(options, onProgress) {
   const reports = [];
   for (const { projectRoot, targetRoot } of projectTargets) {
     let report2;
-    const projectName = projectTargets.length > 1 ? path12.relative(displayRoot, projectRoot) || "." : undefined;
+    const projectName = projectTargets.length > 1 ? path13.relative(displayRoot, projectRoot) || "." : undefined;
     const projectProgress = onProgress ? (progress) => onProgress({
       ...progress,
       phase: [projectName, progress.phase].filter(Boolean).join(":") || undefined,
@@ -12368,7 +12623,7 @@ async function runScan(options, onProgress) {
       `[debug] target=${target}`,
       `[debug] config=${loaded.filename ?? "none"}`,
       `[debug] scope=${report.scope ?? scope} base=${report.base ?? resolvedScope.base ?? "auto"}`,
-      `[debug] projects=${projectTargets.map(({ projectRoot }) => path12.relative(displayRoot, projectRoot) || ".").join(",")}`,
+      `[debug] projects=${projectTargets.map(({ projectRoot }) => path13.relative(displayRoot, projectRoot) || ".").join(",")}`,
       `[debug] candidates=${report.candidateFiles ?? 0} scanned=${report.scannedFiles} partial=${Boolean(report.partial)}`,
       `[debug] parallel=${!options.noParallel}`
     ];
@@ -12381,6 +12636,14 @@ async function runScan(options, onProgress) {
 async function main() {
   try {
     const argv = process.argv.slice(2);
+    if (argv[0] === "__update-cache") {
+      await refreshUpdateCache({ silent: true });
+      return;
+    }
+    if (argv[0] === "update") {
+      await runUpdateCommand(argv.slice(1));
+      return;
+    }
     if (argv[0] === "ci") {
       await runCiCommand(argv.slice(1));
       return;
@@ -12431,6 +12694,9 @@ ${os2.release()}
     }
     const machineReadable = options.scoreOnly || options.json || options.annotations;
     const colorized = shouldUseColor(options.noColor, machineReadable);
+    const updateNoticeEnabled = automaticUpdateNoticeEnabled(options, machineReadable);
+    if (updateNoticeEnabled)
+      startBackgroundUpdateRefresh();
     const progress = createProgressRenderer({
       enabled: Boolean(process.stdout.isTTY && !process.env.CI && !machineReadable),
       colorized
@@ -12445,12 +12711,12 @@ ${os2.release()}
     const json = `${serializeReport(report, compactJson)}
 `;
     if (options.jsonOut) {
-      const outputPath = path12.resolve(process.cwd(), options.jsonOut);
-      fs10.mkdirSync(path12.dirname(outputPath), { recursive: true });
-      fs10.writeFileSync(outputPath, json);
+      const outputPath = path13.resolve(process.cwd(), options.jsonOut);
+      fs11.mkdirSync(path13.dirname(outputPath), { recursive: true });
+      fs11.writeFileSync(outputPath, json);
     }
     if (options.outputDir)
-      writeDiagnosticsDump(path12.resolve(process.cwd(), options.outputDir), report);
+      writeDiagnosticsDump(path13.resolve(process.cwd(), options.outputDir), report);
     const config = loadConfigWithSource(process.cwd()).config;
     const showScore = options.showScore ?? true;
     const verbose = options.verbose ?? config.verbose ?? false;
@@ -12467,6 +12733,13 @@ ${os2.release()}
     } else
       process.stdout.write(`${renderTextReport(report, showScore, colorized, verbose, process.stdout.columns ?? 120)}
 `);
+    if (updateNoticeEnabled) {
+      const update = getCachedUpdateNotice(VERSION2);
+      if (update)
+        process.stdout.write(`
+${renderUpdateNotice(update.current, update.latest, colorized)}
+`);
+    }
     const blocking = options.blocking ?? config.blocking ?? "error";
     if (shouldBlock2(report, blocking))
       process.exitCode = 1;
@@ -12479,5 +12752,5 @@ ${os2.release()}
 }
 main();
 
-//# debugId=77F2455CC417160A64756E2164756E21
+//# debugId=53584D6CB0EB00E064756E2164756E21
 //# sourceMappingURL=cli.js.map