glotfile 0.4.6 → 0.5.1

package/dist/server/cli.js

@@ -176,9 +176,6 @@ function validate(raw) {
     if (lint.ignore !== void 0 && (!Array.isArray(lint.ignore) || !lint.ignore.every((g) => typeof g === "string"))) {
       fail("config.lint.ignore must be an array of strings");
     }
-    if (lint.dictionary !== void 0 && (!Array.isArray(lint.dictionary) || !lint.dictionary.every((w) => typeof w === "string"))) {
-      fail("config.lint.dictionary must be an array of strings");
-    }
     if (lint.spelling !== void 0) {
       if (!isObject(lint.spelling)) fail("config.lint.spelling must be an object");
       if (lint.spelling.locales !== void 0 && (!isObject(lint.spelling.locales) || !Object.values(lint.spelling.locales).every((v) => typeof v === "string"))) {
@@ -243,6 +240,20 @@ function validate(raw) {
         lv.value = lv.value.trim();
       }
     }
+    if (entry.suppressions !== void 0) {
+      if (!Array.isArray(entry.suppressions)) fail(`key "${key}" suppressions must be an array`);
+      for (const s of entry.suppressions) {
+        if (!isObject(s) || typeof s.locale !== "string" || typeof s.source !== "string") {
+          fail(`key "${key}" has an invalid suppression (needs string rule, locale, source)`);
+        }
+        if (!RULE_IDS.includes(s.rule)) {
+          fail(`key "${key}" suppression has unknown rule id "${String(s.rule)}"`);
+        }
+        if (s.at !== void 0 && typeof s.at !== "string") {
+          fail(`key "${key}" suppression "at" must be a string`);
+        }
+      }
+    }
     if (entry.notes !== void 0) {
       if (!Array.isArray(entry.notes)) fail(`key "${key}" notes must be an array`);
       for (const n of entry.notes) {
@@ -520,6 +531,36 @@ var init_normalize = __esm({
   }
 });
 
+// src/server/lint/suppress.ts
+import { createHash } from "crypto";
+function sourceSignature(entry, sourceLocale) {
+  const lv = entry.values[sourceLocale];
+  if (entry.plural) {
+    return Object.entries(lv?.forms ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([cat, body]) => `${cat}:${normalizeSource(body ?? "")}`).join("|");
+  }
+  return normalizeSource(lv?.value ?? "");
+}
+function sourceHash(entry, sourceLocale) {
+  return createHash("sha256").update(sourceSignature(entry, sourceLocale)).digest("hex").slice(0, 12);
+}
+function findSuppression(entry, sourceLocale, ruleId, locale) {
+  if (!entry.suppressions?.length) return void 0;
+  const current = sourceHash(entry, sourceLocale);
+  return entry.suppressions.find((s) => s.rule === ruleId && s.locale === locale && s.source === current);
+}
+function pruneStaleSuppressions(entry, sourceLocale) {
+  if (!entry.suppressions?.length) return;
+  const current = sourceHash(entry, sourceLocale);
+  entry.suppressions = entry.suppressions.filter((s) => s.source === current);
+  if (!entry.suppressions.length) delete entry.suppressions;
+}
+var init_suppress = __esm({
+  "src/server/lint/suppress.ts"() {
+    "use strict";
+    init_normalize();
+  }
+});
+
 // src/server/state.ts
 import { readFileSync as readFileSync2, existsSync as existsSync2, rmSync as rmSync3 } from "fs";
 import { randomUUID } from "crypto";
@@ -541,6 +582,7 @@ function normalizeState(state) {
     const remapped = {};
     for (const [loc, lv] of Object.entries(entry.values)) remapped[canonLocale(loc)] = lv;
     entry.values = remapped;
+    for (const s of entry.suppressions ?? []) s.locale = canonLocale(s.locale);
   }
   for (const output of state.config.outputs) {
     if (!output.localeMap) continue;
@@ -641,6 +683,7 @@ function setSourceValue(state, key, value) {
         lv.state = "needs-review";
       }
     }
+    pruneStaleSuppressions(entry, state.config.sourceLocale);
   }
 }
 function setTargetValue(state, key, locale, value, clock = systemClock) {
@@ -664,6 +707,7 @@ function setSourcePluralForms(state, key, forms) {
         lv.state = "needs-review";
       }
     }
+    pruneStaleSuppressions(entry, state.config.sourceLocale);
   }
 }
 function setPluralForms(state, key, locale, forms, clock = systemClock) {
@@ -737,6 +781,19 @@ function deleteNote(state, key, id) {
   if (!entry.notes) return;
   entry.notes = entry.notes.filter((n) => n.id !== id);
 }
+function addSuppression(state, key, rule, locale, clock = systemClock) {
+  const entry = requireKey(state, key);
+  if (!RULE_IDS.includes(rule)) throw new GlotfileError(`Unknown lint rule: ${rule}`);
+  const list = (entry.suppressions ?? []).filter((s) => !(s.rule === rule && s.locale === locale));
+  list.push({ rule, locale, source: sourceHash(entry, state.config.sourceLocale), at: clock() });
+  entry.suppressions = list;
+}
+function removeSuppression(state, key, rule, locale) {
+  const entry = requireKey(state, key);
+  if (!entry.suppressions) return;
+  entry.suppressions = entry.suppressions.filter((s) => !(s.rule === rule && s.locale === locale));
+  if (!entry.suppressions.length) delete entry.suppressions;
+}
 function upsertGlossaryEntry(state, entry) {
   const i = state.glossary.findIndex((e) => e.term === entry.term);
   if (i === -1) state.glossary.push(entry);
@@ -782,6 +839,8 @@ var init_state = __esm({
     init_plurals();
     init_storage();
     init_normalize();
+    init_suppress();
+    init_registry();
     systemClock = () => (/* @__PURE__ */ new Date()).toISOString();
   }
 });
@@ -2747,7 +2806,7 @@ function attachScreenshotsForProvider(reqs, state, projectRoot, supportsVision)
   const keys = new Set(reqs.filter((r) => state.keys[r.key]?.screenshot).map((r) => r.key));
   return { skipped: keys.size };
 }
-async function runLocaleParallel(reqs, provider, hooks = {}, concurrency = DEFAULT_LOCALE_CONCURRENCY, signal) {
+async function runLocaleParallel(reqs, provider, hooks = {}, concurrency = DEFAULT_LOCALE_CONCURRENCY, signal, batchSize = Infinity) {
   if (!reqs.length) return [];
   const byLocale = /* @__PURE__ */ new Map();
   for (const req of reqs) {
@@ -2758,26 +2817,42 @@ async function runLocaleParallel(reqs, provider, hooks = {}, concurrency = DEFAU
     }
     group.push(req);
   }
+  const localeBatches = [...byLocale.entries()].map(([locale, group]) => ({
+    locale,
+    batches: chunk(group, Math.max(1, batchSize))
+  }));
+  const jobs = [];
+  const maxBatches = Math.max(...localeBatches.map((g) => g.batches.length));
+  for (let i = 0; i < maxBatches; i++) {
+    for (const g of localeBatches) {
+      if (i < g.batches.length) jobs.push({ locale: g.locale, batch: g.batches[i] });
+    }
+  }
+  const remaining = new Map(localeBatches.map((g) => [g.locale, g.batches.length]));
+  const started = /* @__PURE__ */ new Set();
   const total = reqs.length;
   let done = 0;
   const allResults = [];
-  const groups = [...byLocale.values()];
   let next = 0;
   async function worker() {
-    while (next < groups.length) {
+    while (next < jobs.length) {
       if (signal?.aborted) break;
-      const group = groups[next++];
-      const locale = group[0].targetLocale;
-      hooks.onLocaleStart?.(locale);
-      const localeResults = await provider.translate(group, (_localeDone, _localeTotal, batchResults) => {
-        done += batchResults.length;
-        hooks.onBatchComplete?.(done, total, batchResults, locale);
-      }, signal, (raw, batchSize) => hooks.onMalformedReply?.(raw, batchSize, locale));
-      allResults.push(...localeResults);
-      if (!signal?.aborted) hooks.onLocaleDone?.(locale);
+      const { locale, batch } = jobs[next++];
+      if (!started.has(locale)) {
+        started.add(locale);
+        hooks.onLocaleStart?.(locale);
+      }
+      const batchResults = await provider.translate(batch, (_localeDone, _localeTotal, results) => {
+        done += results.length;
+        hooks.onBatchComplete?.(done, total, results, locale);
+      }, signal, (raw, size) => hooks.onMalformedReply?.(raw, size, locale));
+      allResults.push(...batchResults);
+      const left = remaining.get(locale) - 1;
+      remaining.set(locale, left);
+      if (left === 0 && !signal?.aborted) hooks.onLocaleDone?.(locale);
     }
   }
-  const workers = Array.from({ length: Math.min(concurrency, groups.length) }, worker);
+  const workers = Array.from({ length: Math.min(concurrency, jobs.length) }, worker);
   await Promise.all(workers);
   return allResults;
 }
@@ -2813,6 +2888,7 @@ var init_run = __esm({
     init_plurals();
     init_state();
     init_glob();
+    init_batch();
     MEDIA_TYPES = {
       ".png": "image/png",
       ".jpg": "image/jpeg",
@@ -3705,7 +3781,10 @@ function sortFindings(findings) {
 }
 function countSeverities(findings) {
   let error = 0, warn = 0;
-  for (const f of findings) f.severity === "error" ? error++ : warn++;
+  for (const f of findings) {
+    if (f.suppressed) continue;
+    f.severity === "error" ? error++ : warn++;
+  }
   return { error, warn };
 }
 async function loadSpellers(locales, config, load, warn) {
@@ -3731,7 +3810,7 @@ async function runLint(state, options = {}) {
   const active = rules.filter(isActive);
   const spellingOn = active.some((r) => r.id === "spelling");
   const spellers = spellingOn ? await loadSpellers(targetLocales, config, load, warn) : /* @__PURE__ */ new Map();
-  const allowWords = spellingOn ? buildAllowWords(state.glossary, config.dictionary) : /* @__PURE__ */ new Set();
+  const allowWords = spellingOn ? buildAllowWords(state.glossary, state.config.spelling?.customWords) : /* @__PURE__ */ new Set();
   const ctx = {
     config,
     sourceLocale: state.config.sourceLocale,
@@ -3743,16 +3822,23 @@ async function runLint(state, options = {}) {
   const ignoreRes = (config.ignore ?? []).map(globToRegExp);
   const localeFilter = options.locales ? new Set(options.locales) : null;
   const findings = [];
+  let suppressed = 0;
   for (const rule of active) {
     const severity = resolveSeverity(rule.id, config);
     for (const raw of rule.run(state, ctx)) {
       if (ignoreRes.some((re) => re.test(raw.key))) continue;
       if (localeFilter && raw.locale !== "" && !localeFilter.has(raw.locale)) continue;
+      const entry = state.keys[raw.key];
+      if (raw.locale !== "" && entry && findSuppression(entry, state.config.sourceLocale, rule.id, raw.locale)) {
+        suppressed++;
+        if (options.includeSuppressed) findings.push({ ...raw, severity, suppressed: true });
+        continue;
+      }
       findings.push({ ...raw, severity });
     }
   }
   const sorted = sortFindings(findings);
-  const counts = countSeverities(sorted);
+  const counts = { ...countSeverities(sorted), suppressed };
   return { findings: sorted, counts, ok: counts.error === 0 };
 }
 var init_run2 = __esm({
@@ -3762,6 +3848,7 @@ var init_run2 = __esm({
     init_registry();
     init_rules();
     init_spelling();
+    init_suppress();
   }
 });
 
@@ -3791,6 +3878,33 @@ var init_outputs = __esm({
   }
 });
 
+// src/server/lint/accept.ts
+var accept_exports = {};
+__export(accept_exports, {
+  acceptFindings: () => acceptFindings
+});
+function acceptFindings(state, findings, opts = {}, clock = systemClock) {
+  const byRule = {};
+  let accepted = 0;
+  for (const f of findings) {
+    if (f.locale === "" || f.suppressed) continue;
+    if (f.severity === "error" && !opts.includeErrors) continue;
+    if (opts.rules && !opts.rules.includes(f.ruleId)) continue;
+    if (opts.locales && !opts.locales.includes(f.locale)) continue;
+    if (!state.keys[f.key]) continue;
+    addSuppression(state, f.key, f.ruleId, f.locale, clock);
+    byRule[f.ruleId] = (byRule[f.ruleId] ?? 0) + 1;
+    accepted++;
+  }
+  return { accepted, byRule };
+}
+var init_accept = __esm({
+  "src/server/lint/accept.ts"() {
+    "use strict";
+    init_state();
+  }
+});
+
 // src/server/import/detect.ts
 import { existsSync as existsSync10, readdirSync as readdirSync4, statSync as statSync3 } from "fs";
 import { join as join4 } from "path";
@@ -4465,7 +4579,8 @@ function contains(haystack, needle, caseSensitive) {
   return caseSensitive ? haystack.includes(needle) : haystack.toLowerCase().includes(needle.toLowerCase());
 }
 function runChecks(state, opts = {}) {
-  const on = (id) => !opts.only || opts.only.includes(id);
+  const ruleOff = (id) => state.config.lint?.rules?.[CHECK_RULE[id]] === "off";
+  const on = (id) => (!opts.only || opts.only.includes(id)) && !ruleOff(id);
   const issues = [];
   let spellPending = false;
   const { sourceLocale } = state.config;
@@ -4593,16 +4708,28 @@ function runChecks(state, opts = {}) {
       }
     }
   }
-  return { issues, spellPending };
+  const visible = issues.filter((i) => {
+    const entry = state.keys[i.key];
+    return !entry || !findSuppression(entry, sourceLocale, CHECK_RULE[i.check], i.locale);
+  });
+  return { issues: visible, spellPending };
 }
-var CHECK_IDS;
+var CHECK_IDS, CHECK_RULE;
 var init_checks = __esm({
   "src/server/checks.ts"() {
     "use strict";
     init_placeholders();
     init_run();
     init_spell();
+    init_suppress();
     CHECK_IDS = ["untranslated", "placeholder", "spelling", "length", "glossary"];
+    CHECK_RULE = {
+      untranslated: "empty-translation",
+      placeholder: "placeholder-mismatch",
+      spelling: "spelling",
+      length: "max-length",
+      glossary: "glossary-violation"
+    };
   }
 });
 
@@ -4620,19 +4747,23 @@ function readJson2(path) {
 }
 function loadUiPrefs(path) {
   const raw = readJson2(path);
-  return { theme: isThemeMode(raw.theme) ? raw.theme : DEFAULTS.theme };
+  const prefs = { theme: isThemeMode(raw.theme) ? raw.theme : DEFAULTS.theme };
+  if (isPanelWidth(raw.keyColumnWidth)) prefs.keyColumnWidth = Math.round(raw.keyColumnWidth);
+  if (isPanelWidth(raw.detailPanelWidth)) prefs.detailPanelWidth = Math.round(raw.detailPanelWidth);
+  return prefs;
 }
 function saveUiPrefs(path, prefs) {
   const merged = { ...readJson2(path), ...prefs };
   writeFileAtomic(path, JSON.stringify(merged, null, 2) + "\n");
 }
-var THEMES, isThemeMode, defaultUiPrefsPath, DEFAULTS;
+var THEMES, isThemeMode, isPanelWidth, defaultUiPrefsPath, DEFAULTS;
 var init_ui_prefs = __esm({
   "src/server/ui-prefs.ts"() {
     "use strict";
     init_atomic_write();
     THEMES = ["system", "light", "dark"];
     isThemeMode = (v) => THEMES.includes(v);
+    isPanelWidth = (v) => typeof v === "number" && Number.isFinite(v) && v >= 120 && v <= 1200;
     defaultUiPrefsPath = () => join8(homedir(), ".glotfile", "ui.json");
     DEFAULTS = { theme: "system" };
   }
@@ -4687,9 +4818,20 @@ function createApi(deps) {
   app.get("/state", (c) => c.json(load()));
   app.get("/ui-prefs", (c) => c.json(loadUiPrefs(uiPrefsPath)));
   app.put("/ui-prefs", async (c) => {
-    const { theme } = await c.req.json();
-    if (!isThemeMode(theme)) return c.json({ error: "theme must be system, light, or dark" }, 400);
-    saveUiPrefs(uiPrefsPath, { theme });
+    const body = await c.req.json();
+    const patch = {};
+    if ("theme" in body) {
+      if (!isThemeMode(body.theme)) return c.json({ error: "theme must be system, light, or dark" }, 400);
+      patch.theme = body.theme;
+    }
+    for (const field of ["keyColumnWidth", "detailPanelWidth"]) {
+      if (field in body) {
+        if (!isPanelWidth(body[field])) return c.json({ error: `${field} must be a number between 120 and 1200` }, 400);
+        patch[field] = Math.round(body[field]);
+      }
+    }
+    if (Object.keys(patch).length === 0) return c.json({ error: "no recognized preferences in body" }, 400);
+    saveUiPrefs(uiPrefsPath, patch);
     return c.json({ ok: true });
   });
   app.get("/local-settings", (c) => c.json(loadLocalSettings(projectRoot)));
@@ -5163,12 +5305,47 @@ function createApi(deps) {
   };
   app.get("/lint", async (c) => {
     const state = load();
+    const includeSuppressed = c.req.query("includeSuppressed") === "1";
     const lint = await runLint(state, { loadSpeller: cachedLoader, warn: () => {
-    } });
+    }, includeSuppressed });
     const findings = sortFindings([...lint.findings, ...checkOutputs(state, projectRoot)]);
-    const counts = countSeverities(findings);
+    const counts = { ...countSeverities(findings), suppressed: lint.counts.suppressed };
     return c.json({ findings, counts, ok: counts.error === 0 });
   });
+  app.post("/keys/:key/suppressions", async (c) => {
+    const key = c.req.param("key");
+    const { rule, locale } = await c.req.json();
+    if (typeof rule !== "string" || !rule) return c.json({ error: "rule is required" }, 400);
+    if (typeof locale !== "string" || !locale) return c.json({ error: "locale is required" }, 400);
+    const s = load();
+    addSuppression(s, key, rule, locale);
+    persist(s);
+    logChange({ kind: "suppression", summary: `Suppressed ${rule} for ${key} [${locale}]`, key, locale, after: rule });
+    return c.json({ ok: true });
+  });
+  app.delete("/keys/:key/suppressions", (c) => {
+    const key = c.req.param("key");
+    const rule = c.req.query("rule") ?? "";
+    const locale = c.req.query("locale") ?? "";
+    if (!rule || !locale) return c.json({ error: "rule and locale are required" }, 400);
+    const s = load();
+    removeSuppression(s, key, rule, locale);
+    persist(s);
+    logChange({ kind: "suppression", summary: `Unsuppressed ${rule} for ${key} [${locale}]`, key, locale, before: rule });
+    return c.json({ ok: true });
+  });
+  app.post("/lint/accept", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const s = load();
+    const lint = await runLint(s, { loadSpeller: cachedLoader, warn: () => {
+    } });
+    const result = acceptFindings(s, lint.findings, { rules: body.rules, locales: body.locales });
+    if (result.accepted > 0) {
+      persist(s);
+      logChange({ kind: "suppression", summary: `Suppressed ${result.accepted} finding(s)`, after: result.byRule });
+    }
+    return c.json({ ok: true, ...result });
+  });
   app.get("/checks", (c) => {
     const param = c.req.query("checks");
     const only = param ? param.split(",").map((s) => s.trim()).filter((s) => CHECK_IDS.includes(s)) : void 0;
@@ -5293,7 +5470,7 @@ function createApi(deps) {
             raw
           });
         }
-      }, aiCfg.concurrency, signal);
+      }, aiCfg.concurrency, signal, aiCfg.batchSize);
       if (!signal?.aborted) {
         console.log(`[translate] done \u2014 wrote ${totalWritten}, ${allErrors.length} error(s)`);
         await stream.writeSSE({ event: "done", data: JSON.stringify({ written: totalWritten, errors: allErrors }) });
@@ -5336,7 +5513,7 @@ function createApi(deps) {
             raw
           });
         }
-      }, aiCfg.concurrency);
+      }, aiCfg.concurrency, void 0, aiCfg.batchSize);
       const latest = load();
       ({ written, errors } = applyResults(latest, toTranslate, results, void 0, force));
       const entry = {
@@ -5523,6 +5700,7 @@ var init_api = __esm({
   "src/server/api.ts"() {
     "use strict";
     init_state();
+    init_accept();
     init_scan();
     init_scanner();
     init_context();
@@ -5732,10 +5910,11 @@ function formatText(report) {
       lastKey = f.key;
     }
     const loc = f.locale ? ` ${f.locale}` : "";
-    lines.push(`  ${f.severity} ${f.ruleId}${loc}  ${f.message}`);
+    lines.push(`  ${f.severity} ${f.ruleId}${loc}  ${f.message}${f.suppressed ? "  (suppressed)" : ""}`);
   }
   lines.push("");
-  lines.push(`\u2716 ${report.counts.error} error(s), ${report.counts.warn} warning(s)`);
+  const suppressed = report.counts.suppressed ? `, ${report.counts.suppressed} suppressed` : "";
+  lines.push(`\u2716 ${report.counts.error} error(s), ${report.counts.warn} warning(s)${suppressed}`);
   return lines.join("\n") + "\n";
 }
 function formatJson(report) {
@@ -5823,7 +6002,9 @@ function parseArgs(argv) {
     } else if (flag === "--max-warnings" && next) {
       args.maxWarnings = Number(next);
       i++;
-    } else if (flag === "--all") args.all = true;
+    } else if (flag === "--include-suppressed") args.includeSuppressed = true;
+    else if (flag === "--accept") args.accept = true;
+    else if (flag === "--all") args.all = true;
     else if (flag === "--limit" && next) {
       args.limit = Number(next);
       i++;
@@ -5959,7 +6140,7 @@ async function runTranslate(args) {
           raw
         });
       }
-    });
+    }, ai.concurrency, void 0, ai.batchSize);
     process.stdout.write("\n");
     if (!batchCallbackFired) {
       ({ written, errors } = applyResults(state, toTranslate, results));
@@ -5995,8 +6176,24 @@ function printReport(report, format, rawText) {
 }
 async function runLintCmd(args) {
   const state = loadState(args.statePath);
+  if (args.accept) {
+    const { acceptFindings: acceptFindings2 } = await Promise.resolve().then(() => (init_accept(), accept_exports));
+    const report2 = await runLint(state, { locales: args.locales });
+    const result = acceptFindings2(state, report2.findings, { rules: args.ruleIds, locales: args.locales });
+    if (result.accepted > 0) saveState(args.statePath, state);
+    console.log(`Suppressed ${result.accepted} warning(s).`);
+    for (const [rule, n] of Object.entries(result.byRule)) console.log(`  ${rule}: ${n}`);
+    if (result.accepted > 0) {
+      console.log("Each suppression expires automatically when its key's source text changes.");
+    }
+    return;
+  }
   const rawText = existsSync12(args.statePath) ? readFileSync15(args.statePath, "utf8") : "";
-  const report = await runLint(state, { locales: args.locales, ruleIds: args.ruleIds });
+  const report = await runLint(state, {
+    locales: args.locales,
+    ruleIds: args.ruleIds,
+    includeSuppressed: args.includeSuppressed
+  });
   printReport(report, args.format, rawText);
   const tooManyWarnings = args.maxWarnings != null && report.counts.warn > args.maxWarnings;
   if (!report.ok || tooManyWarnings) process.exitCode = 1;
@@ -6008,7 +6205,7 @@ async function runCheck(args) {
   } catch (e) {
     const report2 = {
       findings: [{ ruleId: "load-error", key: "", locale: "", severity: "error", message: e.message }],
-      counts: { error: 1, warn: 0 },
+      counts: { error: 1, warn: 0, suppressed: 0 },
       ok: false
     };
     printReport(report2, args.format, "");
@@ -6019,7 +6216,7 @@ async function runCheck(args) {
   const root = dirname5(resolve11(args.statePath));
   const lint = await runLint(state, {});
   const findings = sortFindings([...lint.findings, ...checkOutputs(state, root)]);
-  const counts = countSeverities(findings);
+  const counts = { ...countSeverities(findings), suppressed: lint.counts.suppressed };
   const report = { findings, counts, ok: counts.error === 0 };
   printReport(report, args.format, rawText);
   if (!report.ok) process.exitCode = 1;
@@ -6206,12 +6403,14 @@ var COMMAND_HELP = {
   },
   lint: {
     summary: "Check the catalog for problems (placeholders, length, glossary, \u2026).",
-    usage: "glotfile lint [--format <text|json|sarif>] [--locale <list>] [--rule <list>] [--max-warnings <n>]",
+    usage: "glotfile lint [--format <text|json|sarif>] [--locale <list>] [--rule <list>] [--max-warnings <n>] [--include-suppressed] [--accept]",
     options: [
       ["--format <fmt>", "Output format: text (default), json, or sarif"],
       ["--locale <list>", "Restrict to these comma-separated locales"],
       ["--rule <list>", "Only run these comma-separated rule ids"],
-      ["--max-warnings <n>", "Exit non-zero if warnings exceed n"]
+      ["--max-warnings <n>", "Exit non-zero if warnings exceed n"],
+      ["--include-suppressed", "Also show findings hidden by suppressions"],
+      ["--accept", "Suppress all current warnings (narrow with --rule/--locale); each expires when its source changes"]
     ]
   },
   check: {