@colrealpro/react-luau-doctor 0.18.1 → 0.18.3

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.1",
+  version: "0.18.3",
   description: "Static analysis for React-Luau hooks, effects, rendering, and performance.",
   license: "MIT",
   type: "module",
@@ -2141,6 +2141,71 @@ function applyMasks(source, ranges) {
   }
   return output;
 }
+function genericFunctionParameterRanges(source, mask) {
+  const ranges = [];
+  const functionPattern = /\bfunction\b/g;
+  for (const match of source.matchAll(functionPattern)) {
+    const start = match.index;
+    if (!isCode(mask, start, start + match[0].length))
+      continue;
+    let cursor = start + match[0].length;
+    while (cursor < source.length) {
+      const char = source[cursor];
+      if (/\s/.test(char)) {
+        cursor += 1;
+        continue;
+      }
+      if (char === "(")
+        break;
+      if (char === "<") {
+        let depth = 0;
+        const rangeStart = cursor;
+        while (cursor < source.length) {
+          if (isCode(mask, cursor)) {
+            if (source[cursor] === "<")
+              depth += 1;
+            else if (source[cursor] === ">") {
+              depth -= 1;
+              if (depth === 0) {
+                cursor += 1;
+                ranges.push({ start: rangeStart, end: cursor });
+                break;
+              }
+            }
+          }
+          cursor += 1;
+        }
+        break;
+      }
+      if (/[A-Za-z0-9_.:]/.test(char)) {
+        cursor += 1;
+        continue;
+      }
+      break;
+    }
+  }
+  return ranges;
+}
+function normalizeGenericTypePackUses(source, mask) {
+  const declarationRanges = genericFunctionParameterRanges(source, mask);
+  const replacements = [];
+  const packPattern = /\b[A-Za-z_][A-Za-z0-9_]*\.\.\./g;
+  for (const match of source.matchAll(packPattern)) {
+    const start = match.index;
+    const end = start + match[0].length;
+    if (!isCode(mask, start, end))
+      continue;
+    if (declarationRanges.some((range) => start >= range.start && end <= range.end))
+      continue;
+    const name = match[0].slice(0, -3);
+    replacements.push({ start, end, value: `...${name}` });
+  }
+  let output = source;
+  for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
+    output = `${output.slice(0, replacement.start)}${replacement.value}${output.slice(replacement.end)}`;
+  }
+  return output;
+}
 function normalizeIntegerLiteralSuffixes(source, mask) {
   const suffixes = [];
   const integerPattern = /\b(?:0[xX][0-9A-Fa-f_]+|0[bB][01_]+|[0-9][0-9_]*)i\b/g;
@@ -2180,13 +2245,14 @@ function parserCompatibleSource(source) {
   const mask = codeMask(source);
   const keywordCompatible = replaceContextualKeywords(source, mask);
   const literalCompatible = normalizeIntegerLiteralSuffixes(keywordCompatible, mask);
+  const packCompatible = normalizeGenericTypePackUses(literalCompatible, mask);
   const ranges = [
     ...maskTypeAliases(source, mask),
     ...maskTypeLevelBlocks(source, mask),
     ...attributeRanges(source, mask),
     ...explicitTypeArgumentRanges(source, mask)
   ];
-  const masked = applyMasks(literalCompatible, ranges);
+  const masked = applyMasks(packCompatible, ranges);
   return masked.replace(/^(\s*)type(?=\s*(?:\+=|-=|\*=|\/=|%=|\^=|\.\.=|=(?!=)))/gm, "$1_typ");
 }
 
@@ -10698,6 +10764,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": {
@@ -11184,6 +11454,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:
@@ -11212,6 +11483,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
@@ -11224,6 +11496,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]
@@ -11236,6 +11512,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 };
@@ -11641,6 +11964,7 @@ function parseArgs(argv) {
     noColor: false,
     noCache: false,
     noParallel: false,
+    noUpdateCheck: false,
     help: false,
     version: false
   };
@@ -11678,6 +12002,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")
@@ -11795,8 +12121,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 }];
@@ -11805,17 +12131,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) {
@@ -11833,15 +12159,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",
@@ -11877,7 +12203,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);
   }
@@ -11986,7 +12312,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;
   }
@@ -12005,7 +12331,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;
   }
@@ -12015,7 +12341,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;
   }
@@ -12038,7 +12364,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;
   }
@@ -12122,7 +12448,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;
@@ -12230,13 +12556,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?.();
@@ -12277,16 +12603,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);
@@ -12316,7 +12642,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,
@@ -12363,7 +12689,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}`
     ];
@@ -12376,6 +12702,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;
@@ -12426,6 +12760,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
@@ -12440,12 +12777,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;
@@ -12462,6 +12799,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;
@@ -12474,5 +12818,5 @@ ${os2.release()}
 }
 main();
 
-//# debugId=93BE5E0B263571E264756E2164756E21
+//# debugId=32BB85E7FBDD457564756E2164756E21
 //# sourceMappingURL=cli.js.map