@mintlify/cli 4.0.1739 → 4.0.1741

package/src/helpers.tsx

@@ -248,6 +248,9 @@ export const readLocalOpenApiFile = async (
   return document;
 };
 
+export const errorMessage = (error: unknown) =>
+  error instanceof Error ? error.message : String(error);
+
 export const terminate = async (code: number) => {
   // Wait for the logs to be fully rendered before exiting
   await new Promise((resolve) => setTimeout(resolve, 50));

package/src/validate/command.tsx

@@ -1,18 +1,22 @@
-import { addLog, clearLogs, ErrorLog, SpinnerLog } from '@mintlify/previewing';
+import { addLog, checkBuild, clearLogs, ErrorLog, SpinnerLog } from '@mintlify/previewing';
 import path from 'node:path';
 
-import { CMD_EXEC_PATH, terminate } from '../helpers.js';
-import { NoMatchingFilesError, resolveExplicitFiles } from '../resolveFiles.js';
-import { checkSite, selectRules, UsageError } from './engine.js';
-import { logDiagnostics } from './output.js';
+import { CMD_EXEC_PATH, errorMessage, getVersions, terminate } from '../helpers.js';
+import { resolveExplicitFiles } from '../resolveFiles.js';
+import { sendPublishPrompt } from '../signup.js';
+import { checkSite, runBuildChecks, selectRules } from './engine.js';
+import { logReport } from './output.js';
+import { toReport, type BuildStatus } from './report.js';
 
 export type ValidateArgs = {
   'local-schema': boolean;
   'client-version'?: string;
   groups?: (string | number)[];
   files?: (string | number)[];
+  build: boolean;
   enable?: string[];
   disable?: string[];
+  fix: boolean;
 };
 
 export const EXIT = { passed: 0, failed: 1, crashed: 2 } as const;
@@ -25,8 +29,6 @@ export const splitList = (values: string[]) =>
       .filter(Boolean)
   );
 
-const errorMessage = (error: unknown) => (error instanceof Error ? error.message : String(error));
-
 const resolveSelection = async (baseDir: string, values: (string | number)[] | undefined) => {
   const args = (values ?? []).map(String).filter(Boolean);
   if (args.length === 0) return undefined;
@@ -38,10 +40,12 @@ const resolveSelection = async (baseDir: string, values: (string | number)[] | u
   );
 };
 
-export const runLintStep = async (
+/** mint validate: one pass over every selected rule, then the strict build when nothing failed. */
+export const validateHandler = async (
   argv: ValidateArgs,
+  packageName: string,
   baseDir = CMD_EXEC_PATH
-): Promise<boolean> => {
+) => {
   try {
     const rules = selectRules({
       enable: argv.enable,
@@ -50,22 +54,45 @@ export const runLintStep = async (
     const selected = await resolveSelection(baseDir, argv.files);
     addLog(<SpinnerLog message="validating..." />);
 
-    const { diagnostics } = await checkSite(baseDir, rules, {
+    const { site, fixed, ...checked } = await checkSite(baseDir, rules, {
       selected,
       localSchema: argv['local-schema'],
+      fix: argv.fix,
     });
-    clearLogs();
-    const failed = logDiagnostics(diagnostics);
-    if (failed) {
-      await terminate(EXIT.failed);
-      return false;
+    let { diagnostics } = checked;
+
+    const buildRules = rules.some(({ needsBuild }) => needsBuild);
+    let build: BuildStatus;
+    if (!argv.build) {
+      build = { ran: false, reason: 'disabled' };
+    } else if (!buildRules) {
+      build = { ran: false, reason: 'no build rules' };
+    } else if (diagnostics.some(({ severity }) => severity === 'error')) {
+      build = { ran: false, reason: 'errors found' };
+    } else {
+      addLog(<SpinnerLog message="building..." />);
+      const { cli: cliVersion } = getVersions(packageName);
+      site.build = await checkBuild({
+        ...argv,
+        _: [],
+        $0: packageName,
+        packageName,
+        cliVersion,
+        disableOpenapi: !rules.some(({ group }) => group === 'openapi'),
+      });
+      diagnostics = await runBuildChecks(site, rules, diagnostics);
+      build = { ran: true, passed: site.build.passed };
     }
-    return true;
+
+    const report = toReport(diagnostics, build, argv.fix ? fixed : undefined);
+    clearLogs();
+    logReport(report);
+    if (report.passed && build.ran && build.passed) await sendPublishPrompt();
+    await terminate(report.passed ? EXIT.passed : EXIT.failed);
   } catch (error) {
-    const usage = error instanceof UsageError || error instanceof NoMatchingFilesError;
+    // Bad arguments and crashes alike mean validate could not run
     clearLogs();
     addLog(<ErrorLog message={errorMessage(error)} />);
-    await terminate(usage ? EXIT.failed : EXIT.crashed);
-    return false;
+    await terminate(EXIT.crashed);
   }
 };

package/src/validate/engine.ts

@@ -1,11 +1,19 @@
-import { checkFiles } from './files.js';
+import { replaceVariables } from '@mintlify/common';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { checkFiles, parseFile } from './files.js';
+import { applyEdits, selectEdits, toPosition } from './mdx.js';
+import { buildFindings } from './rules/build.js';
 import { RULES } from './rules/index.js';
 import { PARSE_ERROR } from './rules/parseError.js';
 import { loadSite } from './site.js';
 import {
   GROUPS,
+  type Change,
   type Diagnostic,
   type DiagnosticSource,
+  type FileEdit,
   type FileRule,
   type Finding,
   type Rule,
@@ -63,24 +71,126 @@ const sortDiagnostics = (diagnostics: Diagnostic[]) =>
       (RULE_ORDER.get(a.rule) ?? 0) - (RULE_ORDER.get(b.rule) ?? 0)
   );
 
-/** Runs every selected rule that doesn't need the build. */
-export const runChecks = async (site: Site, rules: Rule[]) => {
-  const fileRules = rules.filter((rule): rule is FileRule => rule.scope === 'file');
-  const diagnostics = await checkFiles(site, fileRules);
+/** Adds findings for a rule unless a diagnostic of that rule already has the same key. */
+const merge = (
+  diagnostics: Diagnostic[],
+  source: DiagnosticSource,
+  extra: Finding[],
+  key: (item: Pick<Diagnostic, 'file' | 'message'>) => string
+) => {
+  const reported = new Set(diagnostics.filter((item) => item.rule === source.id).map(key));
+  for (const finding of extra) {
+    if (reported.has(key(finding))) continue;
+    reported.add(key(finding));
+    diagnostics.push(toDiagnostic(source, finding));
+  }
+};
+
+const addParseErrors = (site: Site, diagnostics: Diagnostic[], extra: Finding[]) =>
+  merge(
+    diagnostics,
+    PARSE_ERROR,
+    extra.filter(({ file }) => !site.selected || site.selected.has(file)),
+    ({ file }) => file
+  );
 
+const fileRulesOf = (rules: Rule[]) =>
+  rules.filter((rule): rule is FileRule => rule.scope === 'file');
+
+const runSiteRules = async (
+  site: Site,
+  rules: Rule[],
+  needsBuild: boolean,
+  diagnostics: Diagnostic[]
+) => {
   for (const rule of rules) {
-    if (rule.scope !== 'site' || rule.needsBuild) continue;
+    if (rule.scope !== 'site' || Boolean(rule.needsBuild) !== needsBuild) continue;
     for (const finding of await rule.check(site)) diagnostics.push(toDiagnostic(rule, finding));
   }
+};
+
+/** Runs every selected rule that doesn't need the build. */
+export const runChecks = async (site: Site, rules: Rule[]) => {
+  const diagnostics = await checkFiles(site, fileRulesOf(rules));
+  await runSiteRules(site, rules, false, diagnostics);
+  return sortDiagnostics(diagnostics);
+};
+
+/** Adds the build's findings to a site whose build has run. */
+export const runBuildChecks = async (site: Site, rules: Rule[], diagnostics: Diagnostic[]) => {
+  await runSiteRules(site, rules, true, diagnostics);
+  // The file pass already reported files it couldn't parse; the build adds the rest
+  addParseErrors(site, diagnostics, buildFindings(site, 'parse-error'));
   return sortDiagnostics(diagnostics);
 };
 
-/** Loads the site and runs the selected rules. */
+const parseLevel = (file: string, content: string, baseDir: string) => {
+  const parsed = parseFile(file, content, baseDir);
+  return 'error' in parsed ? 0 : parsed.approximate ? 1 : 2;
+};
+
+/** Applies every fix that doesn't overlap an earlier fix in the same file, writing each Markdown file only when its fixed content parses at least as well as before. */
+export const applyFixes = async (site: Site, diagnostics: Diagnostic[]): Promise<Change[]> => {
+  const contents = new Map<string, string>();
+  const read = async (file: string) => {
+    if (!contents.has(file)) {
+      contents.set(file, await fs.readFile(path.join(site.baseDir, file), 'utf-8'));
+    }
+    return contents.get(file) ?? '';
+  };
+  const chosen = new Map<string, { fix: FileEdit; change: Change }[]>();
+  const overlaps = ({ file, start, end }: FileEdit) =>
+    (chosen.get(file) ?? []).some(({ fix }) => start < fix.end && fix.start < end);
+
+  for (const { rule, fix } of diagnostics) {
+    if (!fix || overlaps(fix)) continue;
+    const content = await read(fix.file);
+    const change = {
+      rule,
+      file: fix.file,
+      ...toPosition(content, fix.start),
+      before: content.slice(fix.start, fix.end),
+      after: fix.text,
+    };
+    chosen.set(fix.file, [...(chosen.get(fix.file) ?? []), { fix, change }]);
+  }
+
+  const snippets = new Set(
+    site.files.filter(({ kind }) => kind === 'snippet').map(({ file }) => file)
+  );
+  const level = (file: string, content: string) =>
+    parseLevel(
+      file,
+      snippets.has(file) ? replaceVariables(content, site.variables) : content,
+      site.baseDir
+    );
+
+  const applied: Change[] = [];
+  for (const [file, picks] of chosen) {
+    const content = await read(file);
+    const updated = applyEdits(content, selectEdits(picks.map(({ fix }) => fix)));
+    if (/\.mdx?$/.test(file) && level(file, updated) < level(file, content)) {
+      continue;
+    }
+    await fs.writeFile(path.join(site.baseDir, file), updated);
+    applied.push(...picks.map(({ change }) => change));
+  }
+  return applied;
+};
+
+// Fixes can unlock others (a self-closed <br> lets a page parse), so --fix runs a few passes
+const MAX_FIX_PASSES = 5;
+
+/**
+ * Loads the site and runs the selected rules. With fix, applies the fixes, rechecks only the
+ * files that changed for further fixes, then runs every rule once more for the final report.
+ */
 export const checkSite = async (
   baseDir: string,
   rules: Rule[],
-  options: { selected?: ReadonlySet<string>; localSchema: boolean }
+  options: { selected?: ReadonlySet<string>; localSchema: boolean; fix: boolean }
 ) => {
+  const fixed: Change[] = [];
   const site = await loadSite(baseDir, options);
   const { selected } = options;
   if (selected && !site.files.some(({ file }) => selected.has(file))) {
@@ -89,5 +199,18 @@ export const checkSite = async (
     );
   }
   const diagnostics = await runChecks(site, rules);
-  return { site, diagnostics };
+  if (!options.fix) return { site, diagnostics, fixed };
+
+  // Only file rules offer fixes, so passes after the first recheck just the files that changed
+  let pending = diagnostics;
+  for (let pass = 0; pass < MAX_FIX_PASSES; pass++) {
+    const changes = await applyFixes(site, pending);
+    if (changes.length === 0) break;
+    fixed.push(...changes);
+    const changed = new Set(changes.map(({ file }) => file));
+    pending = sortDiagnostics(await checkFiles({ ...site, selected: changed }, fileRulesOf(rules)));
+  }
+  if (fixed.length === 0) return { site, diagnostics, fixed };
+  const fixedSite = await loadSite(baseDir, options);
+  return { site: fixedSite, diagnostics: await runChecks(fixedSite, rules), fixed };
 };

package/src/validate/files.ts

@@ -99,7 +99,7 @@ const tryParseContent = (content: string): Root | undefined => {
   }
 };
 
-const parseFile = (file: string, content: string, baseDir: string): Parsed => {
+export const parseFile = (file: string, content: string, baseDir: string): Parsed => {
   const context = { file, content, baseDir, frontmatter: readFrontmatter(content) };
   const tree = tryParseContent(content);
   if (tree) return { context: { ...context, tree }, approximate: false };

package/src/validate/output.tsx

@@ -1,8 +1,14 @@
-import { addLog, ErrorLog } from '@mintlify/previewing';
+import { addLog, ErrorLog, InfoLog, SuccessLog } from '@mintlify/previewing';
 import { Box, Text } from 'ink';
 
+import type { Report } from './report.js';
 import type { Diagnostic } from './types.js';
 
+const preview = (value: string) => {
+  const text = JSON.stringify(value);
+  return text.length > 60 ? `${text.slice(0, 57)}..."` : text;
+};
+
 const location = ({ line, column }: Pick<Diagnostic, 'line' | 'column'>) =>
   line ? `${line}${column ? `:${column}` : ''}` : '';
 
@@ -25,9 +31,17 @@ const DiagnosticLine = ({ diagnostic }: { diagnostic: Diagnostic }) => {
 
 const plural = (count: number, word: string) => `${count} ${word}${count === 1 ? '' : 's'}`;
 
-export const logDiagnostics = (all: Diagnostic[]) => {
+export const logReport = (report: Report) => {
+  for (const change of report.fixed ?? []) {
+    addLog(
+      <SuccessLog
+        message={`fixed ${change.file}${change.line ? `:${change.line}` : ''} ${change.rule}: ${preview(change.before)} → ${preview(change.after)}`}
+      />
+    );
+  }
+
   const byFile = new Map<string, Diagnostic[]>();
-  for (const diagnostic of all) {
+  for (const diagnostic of report.diagnostics) {
     byFile.get(diagnostic.file)?.push(diagnostic) ?? byFile.set(diagnostic.file, [diagnostic]);
   }
   for (const [file, diagnostics] of byFile) {
@@ -41,16 +55,22 @@ export const logDiagnostics = (all: Diagnostic[]) => {
     );
   }
 
-  const errors = all.filter(({ severity }) => severity === 'error').length;
-  const warnings = all.length - errors;
-  if (errors > 0) {
-    addLog(
-      <ErrorLog
-        message={`${plural(errors, 'error')}${warnings > 0 ? `, ${plural(warnings, 'warning')}` : ''}`}
-      />
-    );
-  } else if (warnings > 0) {
-    addLog(<Text dimColor>{plural(warnings, 'warning')}</Text>);
+  const fixable = report.diagnostics.filter(({ fix }) => fix).length;
+  if (fixable > 0 && !report.fixed) {
+    addLog(<InfoLog message={`\`--fix\` would fix ${plural(fixable, 'issue')}.`} />);
   }
-  return errors > 0;
+
+  const { build } = report;
+  if (build.ran && build.passed) addLog(<SuccessLog message="build passed" />);
+  else if (build.ran && report.passed)
+    addLog(<InfoLog message="build failed only on disabled rules" />);
+  else if (build.ran) addLog(<ErrorLog message="build failed" />);
+  else if (build.reason === 'errors found')
+    addLog(<InfoLog message="build skipped until the errors above are fixed" />);
+
+  const { errors, warnings } = report.summary;
+  const warned = plural(warnings, 'warning');
+  const passed = warnings > 0 ? `passed with ${warned}` : 'validation passed';
+  const failed = `${plural(errors, 'error')}${warnings > 0 ? `, ${warned}` : ''}`;
+  addLog(report.passed ? <SuccessLog message={passed} /> : <ErrorLog message={failed} />);
 };

package/src/validate/report.ts

@@ -0,0 +1,40 @@
+import type { Change, Diagnostic } from './types.js';
+
+export type BuildStatus =
+  | { ran: true; passed: boolean }
+  | { ran: false; reason: 'disabled' | 'errors found' | 'no build rules' };
+
+export type Report = {
+  passed: boolean;
+  summary: { errors: number; warnings: number; byRule: Record<string, number> };
+  diagnostics: Diagnostic[];
+  build: BuildStatus;
+  /** With --fix: the edits that were applied. */
+  fixed?: Change[];
+};
+
+export const toReport = (
+  diagnostics: Diagnostic[],
+  build: BuildStatus,
+  fixed?: Change[]
+): Report => {
+  const byRule: Record<string, number> = {};
+  for (const { rule } of diagnostics) byRule[rule] = (byRule[rule] ?? 0) + 1;
+  const errors = diagnostics.filter(({ severity }) => severity === 'error').length;
+  return {
+    passed: errors === 0,
+    summary: { errors, warnings: diagnostics.length - errors, byRule },
+    diagnostics: diagnostics.map(({ rule, group, severity, file, line, column, message, fix }) => ({
+      rule,
+      group,
+      severity,
+      file,
+      ...(line !== undefined && { line }),
+      ...(column !== undefined && { column }),
+      message,
+      ...(fix && { fix }),
+    })),
+    build,
+    ...(fixed && { fixed }),
+  };
+};

package/src/validate/rules/build.ts

@@ -0,0 +1,132 @@
+import { normalizeRelativePath, toPosixPath } from '@mintlify/common';
+import type { Warning } from '@mintlify/prebuild';
+import { stripVTControlCharacters } from 'node:util';
+
+import type { Finding, Group, Site, SiteRule } from '../types.js';
+
+const FILE = String.raw`[\w@.\\/-]+\.(?:mdx?|jsx?|tsx?|json|ya?ml)\b`;
+
+const FILE_IN_MESSAGE = new RegExp(FILE);
+
+const IMPORTERS = [
+  new RegExp(String.raw`\(in (${FILE}),`),
+  new RegExp(String.raw`(?:\bin|imported from) (${FILE})`),
+];
+
+const IMPORT_TYPES = new Set<Warning['type']>([
+  'missing-file',
+  'invalid-import-path',
+  'import-resolution-error',
+  'default-import-no-default-export',
+  'export-collision',
+  'undeclared-package',
+  'package-import-conflict',
+]);
+
+const POSITION = /^:(\d+)(?::(\d+))?/;
+
+const QUOTED = /"([^"]+)"/;
+
+const toFinding = (site: Site, { type, message }: Warning): Finding => {
+  const clean = stripVTControlCharacters(message).trim();
+  const importer = IMPORT_TYPES.has(type)
+    ? IMPORTERS.map((pattern) => pattern.exec(clean)?.[1]).find(Boolean)
+    : undefined;
+  // Missing nav pages are always about the config, even when the page looks like a file
+  const match = importer || type === 'missing-nav-page' ? null : FILE_IN_MESSAGE.exec(clean);
+  const found = importer ?? match?.[0];
+  const file = found ? normalizeRelativePath(toPosixPath(found)) : site.configFile;
+  const position = match ? POSITION.exec(clean.slice(match.index + match[0].length)) : null;
+  // Config warnings quote the entry they're about, such as a navigation page
+  const quoted = file === site.configFile ? QUOTED.exec(clean)?.[0] : undefined;
+  return {
+    file,
+    ...(position && {
+      line: Number(position[1]),
+      ...(position[2] && { column: Number(position[2]) }),
+    }),
+    ...(quoted && site.locate(file, quoted)),
+    message: clean,
+  };
+};
+
+/** Warning types some rule turns into diagnostics, so a strict-build failure is explained. */
+const COVERED_TYPES = new Set<Warning['type']>(['parse-error']);
+
+const buildRule = (
+  id: string,
+  group: Group,
+  types: Warning['type'][],
+  description: string
+): SiteRule => {
+  for (const type of types) COVERED_TYPES.add(type);
+  return {
+    id,
+    group,
+    severity: 'error',
+    needsBuild: true,
+    scope: 'site',
+    description,
+    check: (site) =>
+      (site.build?.warnings ?? [])
+        .filter(({ type }) => types.includes(type))
+        .map((warning) => toFinding(site, warning)),
+  };
+};
+
+export const BUILD_RULES: SiteRule[] = [
+  buildRule(
+    'missing-nav-page',
+    'nav',
+    ['missing-nav-page'],
+    'pages in the navigation that have no file'
+  ),
+  buildRule('missing-file', 'content', ['missing-file'], "imported files that don't exist"),
+  buildRule(
+    'import-error',
+    'content',
+    [
+      'invalid-import-path',
+      'import-resolution-error',
+      'default-import-no-default-export',
+      'export-collision',
+    ],
+    "imports in pages and snippets that don't resolve"
+  ),
+  buildRule(
+    'package-import',
+    'config',
+    ['undeclared-package', 'package-import-conflict'],
+    'npm package imports that are undeclared or conflict'
+  ),
+  buildRule('openapi-build', 'openapi', ['openapi'], 'OpenAPI pages the build could not generate'),
+  {
+    id: 'build-failed',
+    group: 'config',
+    severity: 'error',
+    needsBuild: true,
+    scope: 'site',
+    description: 'the strict build failed for a reason no rule reports',
+    check: (site) => {
+      if (!site.build || site.build.passed) return [];
+      const unreported = (warning: Warning) =>
+        warning.type === 'parse-error' &&
+        site.selected !== undefined &&
+        !site.selected.has(toFinding(site, warning).file);
+      const uncovered = site.build.warnings.filter(
+        (warning) => !COVERED_TYPES.has(warning.type) || unreported(warning)
+      );
+      const findings = uncovered.map((warning) => toFinding(site, warning));
+      // Covered warnings are the selected rules' to report; disabled ones are meant to pass
+      return site.build.strict
+        ? findings
+        : [...findings, { file: site.configFile, message: site.build.error }];
+    },
+  },
+];
+
+/** Build warnings of one type, which the engine merges into the static rule that covers them. */
+export const buildFindings = (site: Site, type: Warning['type']): Finding[] =>
+  (site.build?.warnings ?? [])
+    .filter((warning) => warning.type === type)
+    .map((warning) => toFinding(site, warning));

package/src/validate/rules/index.ts

@@ -1,5 +1,7 @@
 import type { Rule } from '../types.js';
+import { BUILD_RULES } from './build.js';
 import { voidTags } from './content/voidTags.js';
+import { openApiSpec } from './openapi.js';
 
 /** Every check mint validate runs, in report order. */
-export const RULES: Rule[] = [voidTags];
+export const RULES: Rule[] = [voidTags, openApiSpec, ...BUILD_RULES];

package/src/validate/rules/openapi.ts

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { errorMessage } from '../../helpers.js';
+import {
+  buildOverlayRegistryForCheck,
+  checkOpenApiFile,
+  getOpenApiFilenamesFromDocsConfig,
+  type OpenApiCheckMessage,
+} from '../../openApiCheck.js';
+import type { Finding, SiteRule } from '../types.js';
+
+export const openApiSpec: SiteRule = {
+  id: 'openapi-spec',
+  group: 'openapi',
+  severity: 'error',
+  scope: 'site',
+  description:
+    "OpenAPI specs in docs.json or mint.json that don't parse or validate, with overlays applied",
+  check: async (site) => {
+    let filenames: string[] = [];
+    try {
+      const config = JSON.parse(
+        await fs.readFile(path.join(site.baseDir, site.configFile), 'utf-8')
+      );
+      // mint.json lists its specs under a top-level openapi key
+      filenames = getOpenApiFilenamesFromDocsConfig(
+        site.configFile === 'mint.json' ? { api: { openapi: config.openapi } } : config
+      );
+    } catch {
+      // A missing or invalid config file is the build's to report
+    }
+    if (filenames.length === 0) return [];
+
+    let overlayRegistry;
+    try {
+      overlayRegistry = await buildOverlayRegistryForCheck(site.localSchema);
+    } catch (error) {
+      return [{ file: site.configFile, message: `OpenAPI overlays: ${errorMessage(error)}` }];
+    }
+
+    const perFile = await Promise.all(
+      filenames.map(async (file) => {
+        const messages: OpenApiCheckMessage[] = [];
+        await checkOpenApiFile(file, site.localSchema, overlayRegistry, (message) =>
+          messages.push(message)
+        );
+        return messages.flatMap(({ level, message }): Finding[] =>
+          level === 'error'
+            ? [{ file, message }]
+            : level === 'warning'
+              ? [{ file, message, severity: 'warning' }]
+              : []
+        );
+      })
+    );
+    return perFile.flat();
+  },
+};

package/src/validate/types.ts

@@ -11,6 +11,16 @@ export type Edit = { start: number; end: number; text: string };
 
 export type FileEdit = Edit & { file: string };
 
+/** A fix --fix applied: where it was and the text it replaced. */
+export type Change = {
+  rule: string;
+  file: string;
+  line?: number;
+  column?: number;
+  before: string;
+  after: string;
+};
+
 export type Diagnostic = {
   rule: string;
   group: Group;