@mintlify/cli 4.0.1732 → 4.0.1734

package/bin/validate/command.js

@@ -0,0 +1,58 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { addLog, 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';
+export const EXIT = { passed: 0, failed: 1, crashed: 2 };
+export const splitList = (values) => values.flatMap((value) => value
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean));
+const errorMessage = (error) => (error instanceof Error ? error.message : String(error));
+const resolveSelection = (baseDir, values) => __awaiter(void 0, void 0, void 0, function* () {
+    const args = (values !== null && values !== void 0 ? values : []).map(String).filter(Boolean);
+    if (args.length === 0)
+        return undefined;
+    const files = yield resolveExplicitFiles(CMD_EXEC_PATH, args);
+    return new Set(files.map((file) => path.relative(baseDir, path.resolve(CMD_EXEC_PATH, file)).split(path.sep).join('/')));
+});
+export const runLintStep = (argv_1, ...args_1) => __awaiter(void 0, [argv_1, ...args_1], void 0, function* (argv, baseDir = CMD_EXEC_PATH) {
+    var _a;
+    try {
+        const rules = selectRules({
+            enable: argv.enable,
+            disable: (_a = argv.disable) !== null && _a !== void 0 ? _a : [],
+        });
+        const selected = yield resolveSelection(baseDir, argv.files);
+        addLog(_jsx(SpinnerLog, { message: "validating..." }));
+        const { diagnostics } = yield checkSite(baseDir, rules, {
+            selected,
+            localSchema: argv['local-schema'],
+        });
+        clearLogs();
+        const failed = logDiagnostics(diagnostics);
+        if (failed) {
+            yield terminate(EXIT.failed);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        const usage = error instanceof UsageError || error instanceof NoMatchingFilesError;
+        clearLogs();
+        addLog(_jsx(ErrorLog, { message: errorMessage(error) }));
+        yield terminate(usage ? EXIT.failed : EXIT.crashed);
+        return false;
+    }
+});

package/bin/validate/engine.js

@@ -0,0 +1,76 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { checkFiles } from './files.js';
+import { RULES } from './rules/index.js';
+import { PARSE_ERROR } from './rules/parseError.js';
+import { loadSite } from './site.js';
+import { GROUPS, } from './types.js';
+export class UsageError extends Error {
+}
+const ruleList = () => RULES.map(({ id }) => id).join(', ');
+const matchToken = (token) => {
+    if (token === 'all')
+        return RULES;
+    const rule = RULES.find(({ id }) => id === token);
+    if (rule)
+        return [rule];
+    if (GROUPS.includes(token)) {
+        return RULES.filter(({ group }) => group === token);
+    }
+    throw new UsageError(`unknown rule or group "${token}". Groups: all, ${GROUPS.join(', ')}. Rules: ${ruleList()}`);
+};
+/** Every rule, minus --disable, plus --enable. parse-error is the engine's own, not selectable. */
+export const selectRules = ({ enable = [], disable = [], }) => {
+    if ([...disable, ...enable].includes(PARSE_ERROR.id)) {
+        throw new UsageError(`${PARSE_ERROR.id} always runs and can't be disabled`);
+    }
+    const selected = new Set(RULES);
+    for (const token of disable)
+        for (const rule of matchToken(token))
+            selected.delete(rule);
+    for (const token of enable)
+        for (const rule of matchToken(token))
+            selected.add(rule);
+    return RULES.filter((rule) => selected.has(rule));
+};
+const toDiagnostic = (source, finding) => {
+    var _a;
+    return (Object.assign(Object.assign({}, finding), { rule: source.id, group: source.group, severity: (_a = finding.severity) !== null && _a !== void 0 ? _a : source.severity }));
+};
+const RULE_ORDER = new Map(RULES.map(({ id }, index) => [id, index]));
+const sortDiagnostics = (diagnostics) => diagnostics.sort((a, b) => {
+    var _a, _b, _c, _d, _e, _f;
+    return (a.file < b.file ? -1 : a.file > b.file ? 1 : 0) ||
+        ((_a = a.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.line) !== null && _b !== void 0 ? _b : 0) ||
+        ((_c = a.column) !== null && _c !== void 0 ? _c : 0) - ((_d = b.column) !== null && _d !== void 0 ? _d : 0) ||
+        ((_e = RULE_ORDER.get(a.rule)) !== null && _e !== void 0 ? _e : 0) - ((_f = RULE_ORDER.get(b.rule)) !== null && _f !== void 0 ? _f : 0);
+});
+/** Runs every selected rule that doesn't need the build. */
+export const runChecks = (site, rules) => __awaiter(void 0, void 0, void 0, function* () {
+    const fileRules = rules.filter((rule) => rule.scope === 'file');
+    const diagnostics = yield checkFiles(site, fileRules);
+    for (const rule of rules) {
+        if (rule.scope !== 'site' || rule.needsBuild)
+            continue;
+        for (const finding of yield rule.check(site))
+            diagnostics.push(toDiagnostic(rule, finding));
+    }
+    return sortDiagnostics(diagnostics);
+});
+/** Loads the site and runs the selected rules. */
+export const checkSite = (baseDir, rules, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const site = yield loadSite(baseDir, options);
+    const { selected } = options;
+    if (selected && !site.files.some(({ file }) => selected.has(file))) {
+        throw new UsageError(`none of the given files are pages or snippets of this site: ${[...selected].join(', ')}`);
+    }
+    const diagnostics = yield runChecks(site, rules);
+    return { site, diagnostics };
+});

package/bin/validate/files.js

@@ -0,0 +1,148 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { getAST, getFileCategory, parseFrontmatter, replaceVariables } from '@mintlify/common';
+import { categorizeMdxFiles, getErrorPosition, getMintIgnore, listContentFiles, } from '@mintlify/prebuild';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { applyEdits, parseContent, relocate, selectEdits, unmapEdit } from './mdx.js';
+import { PARSE_ERROR } from './rules/parseError.js';
+const CONCURRENCY = 16;
+const mapLimit = (items, task) => __awaiter(void 0, void 0, void 0, function* () {
+    const results = new Array(items.length);
+    let next = 0;
+    yield Promise.all(Array.from({ length: Math.min(CONCURRENCY, items.length) }, () => __awaiter(void 0, void 0, void 0, function* () {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = yield task(items[index]);
+        }
+    })));
+    return results;
+});
+const CHECKED_CATEGORIES = new Set(['page', 'snippet', 'snippet-v2']);
+export const readSiteFiles = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
+    const { mdxCandidates: candidates } = yield listContentFiles(baseDir, yield getMintIgnore(baseDir));
+    const { snippets, snippetsV2 } = yield categorizeMdxFiles(baseDir, candidates);
+    const snippetFiles = new Set([...snippets, ...snippetsV2]);
+    return candidates
+        .filter((name) => /\.mdx?$/.test(name) && CHECKED_CATEGORIES.has(getFileCategory(name)))
+        .map((name) => ({
+        file: name.replace(/^\//, ''),
+        kind: (snippetFiles.has(name) ? 'snippet' : 'page'),
+    }));
+});
+const readFrontmatter = (content) => {
+    try {
+        const { attributes } = parseFrontmatter(content);
+        return attributes && typeof attributes === 'object' ? Object.assign({}, attributes) : {};
+    }
+    catch (_a) {
+        return {};
+    }
+};
+const REASON_POSITION = /\s*\(\d+:\d+(?:-\d+:\d+)?\)$/;
+export const toParseError = (error) => {
+    const reason = error === null || error === void 0 ? void 0 : error.reason;
+    const fallback = error instanceof Error ? error.message : 'could not parse this file';
+    const text = typeof reason === 'string' ? reason : fallback;
+    const position = error && typeof error === 'object' ? getErrorPosition(error) : null;
+    return Object.assign(Object.assign(Object.assign({}, ((position === null || position === void 0 ? void 0 : position.line) != null && { line: position.line })), ((position === null || position === void 0 ? void 0 : position.column) != null && { column: position.column })), { message: text.replace(REASON_POSITION, '') });
+};
+const parseErrorDiagnostic = (file, error) => (Object.assign(Object.assign({}, error), { rule: PARSE_ERROR.id, group: PARSE_ERROR.group, severity: PARSE_ERROR.severity, file, message: `${error.message} (other checks were skipped for this file)` }));
+const tryParseContent = (content) => {
+    try {
+        return parseContent(content);
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+const parseFile = (file, content, baseDir) => {
+    const context = { file, content, baseDir, frontmatter: readFrontmatter(content) };
+    const tree = tryParseContent(content);
+    if (tree)
+        return { context: Object.assign(Object.assign({}, context), { tree }), approximate: false };
+    try {
+        return { context: Object.assign(Object.assign({}, context), { tree: getAST(content, file) }), approximate: true };
+    }
+    catch (error) {
+        return { error: toParseError(error) };
+    }
+};
+const EMPTY_TREE = { type: 'root', children: [] };
+const SOURCE_STAGE = 1;
+const AFTER_RAW_STAGE = 2;
+const VARIABLE = /\{\{\s*([\w.\-]+)\s*\}\}/g;
+const variableEdits = (content, variables = {}) => [...content.matchAll(VARIABLE)]
+    .filter((match) => match[1] !== undefined && variables[match[1]] !== undefined)
+    .map((match) => ({
+    start: match.index,
+    end: match.index + match[0].length,
+    text: replaceVariables(match[0], variables),
+}));
+const toDiagnostic = (rule, file, _a, stages, stage) => {
+    var { edit } = _a, finding = __rest(_a, ["edit"]);
+    const original = edit && unmapEdit(stages, stage, edit);
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, finding), relocate(stages, stage, finding)), { rule: rule.id, group: rule.group, severity: rule.severity, file }), (original && { fix: Object.assign({ file }, original) }));
+};
+const checkFile = (allRules, { file, kind }, content, baseDir, variables) => {
+    const rules = kind === 'snippet' ? allRules.filter((rule) => !rule.pagesOnly) : allRules;
+    const raw = rules.filter((rule) => rule.raw);
+    const treeRules = rules.filter((rule) => !rule.raw);
+    const varEdits = kind === 'snippet' ? variableEdits(content, variables) : [];
+    const source = applyEdits(content, varEdits);
+    const rawContext = { file, content: source, baseDir, frontmatter: {}, tree: EMPTY_TREE };
+    const rawFound = raw.flatMap((rule) => rule.check(rawContext).map((finding) => ({ rule, finding })));
+    const rawEdits = selectEdits(rawFound.flatMap(({ finding }) => (finding.edit ? [finding.edit] : [])));
+    const afterRaw = applyEdits(source, rawEdits);
+    const stages = [
+        { content, edits: varEdits },
+        { content: source, edits: rawEdits },
+        { content: afterRaw, edits: [] },
+    ];
+    const diagnostics = rawFound.map(({ rule, finding }) => toDiagnostic(rule, file, finding, stages, SOURCE_STAGE));
+    const parsed = parseFile(file, afterRaw, baseDir);
+    if ('error' in parsed) {
+        diagnostics.unshift(parseErrorDiagnostic(file, Object.assign(Object.assign({}, parsed.error), relocate(stages, AFTER_RAW_STAGE, parsed.error))));
+        return diagnostics;
+    }
+    for (const rule of treeRules) {
+        for (const finding of rule.check(parsed.context)) {
+            const found = parsed.approximate ? Object.assign(Object.assign({}, finding), { edit: undefined }) : finding;
+            diagnostics.push(toDiagnostic(rule, file, found, stages, AFTER_RAW_STAGE));
+        }
+    }
+    return diagnostics;
+};
+export const checkFiles = (site, rules) => __awaiter(void 0, void 0, void 0, function* () {
+    const targets = site.files.filter(({ file }) => !site.selected || site.selected.has(file));
+    const results = yield mapLimit(targets, (entry) => __awaiter(void 0, void 0, void 0, function* () {
+        let content;
+        try {
+            content = yield fs.readFile(path.join(site.baseDir, entry.file), 'utf-8');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'could not read this file';
+            return [parseErrorDiagnostic(entry.file, { message })];
+        }
+        return checkFile(rules, entry, content, site.baseDir, site.variables);
+    }));
+    return results.flat();
+});

package/bin/validate/mdx.js

@@ -0,0 +1,201 @@
+import { coreRemark, FRONTMATTER_RE, getCodeRanges, HEADING_ID_RE, JSXParser, } from '@mintlify/common';
+const HEADING_ID = new RegExp(HEADING_ID_RE.source, 'gm');
+const ESM_START = /^(?:import|export)(?=[\s{*])/;
+const JSX_TAG = /<[A-Za-z][\w.:-]*(?:"[^"]*"|'[^']*'|\{[^{}]*\}|[^<>"'{}])*>/g;
+const ATTR_VALUE = /"[^"]*"|'[^']*'|\{[^{}]*\}/g;
+export const hasCustomHeadingId = (line) => /\{\s*#[^}]+?\s*\}\s*$/.test(line);
+export const parseContent = (content) => {
+    const padded = content.replace(HEADING_ID, (match, indent, hashes, text) => {
+        const end = match.indexOf(text, indent.length + hashes.length) + text.length;
+        return match.slice(0, end).padEnd(match.length, ' ');
+    });
+    return coreRemark().parse(padded);
+};
+const blankRanges = (content, ranges) => {
+    let result = '';
+    let cursor = 0;
+    for (const [from, to] of [...ranges].sort((a, b) => a[0] - b[0])) {
+        const start = Math.max(from, cursor);
+        if (to <= start)
+            continue;
+        result += content.slice(cursor, start) + content.slice(start, to).replace(/[^\n]/g, ' ');
+        cursor = to;
+    }
+    return result + content.slice(cursor);
+};
+const maskWith = (content, maskers) => maskers.reduce((text, ranges) => blankRanges(text, ranges(text)), content);
+const isCompleteEsm = (text) => {
+    try {
+        JSXParser.parse(text, { ecmaVersion: 'latest', sourceType: 'module' });
+        return true;
+    }
+    catch (error) {
+        const pos = error.pos;
+        return typeof pos !== 'number' || pos < text.trimEnd().length;
+    }
+};
+const frontmatterRanges = (content) => {
+    const match = FRONTMATTER_RE.exec(content);
+    return match ? [[match.index, match.index + match[0].length]] : [];
+};
+const esmRanges = (content, codeRanges) => {
+    let esm;
+    let previousBlank = true;
+    const ranges = [];
+    let offset = 0;
+    for (const line of content.split('\n')) {
+        const isBlank = line.trim() === '';
+        const wasBlank = previousBlank;
+        previousBlank = isBlank;
+        if (esm) {
+            if (isBlank && isCompleteEsm(esm.join('\n')))
+                esm = undefined;
+            else {
+                esm.push(line);
+                ranges.push([offset, offset + line.length]);
+            }
+        }
+        else if (wasBlank &&
+            ESM_START.test(line) &&
+            !codeRanges.some(([start, end]) => start <= offset && offset < end)) {
+            esm = [line];
+            ranges.push([offset, offset + line.length]);
+        }
+        offset += line.length + 1;
+    }
+    return ranges;
+};
+export const maskFrontmatter = (content) => blankRanges(content, frontmatterRanges(content));
+export const maskCode = (content, { keepEsm = false } = {}) => {
+    const codeRanges = getCodeRanges(content);
+    return blankRanges(content, [
+        ...frontmatterRanges(content),
+        ...codeRanges,
+        ...(keepEsm ? [] : esmRanges(content, codeRanges)),
+    ]);
+};
+const OPENS = new Set(['{', '${']);
+const maskExpression = (content, start) => {
+    const ranges = [];
+    let depth = 0;
+    try {
+        const tokens = JSXParser.tokenizer(content.slice(start), {
+            ecmaVersion: 'latest',
+            onComment: (block, _text, from, to) => ranges.push([start + from + 2, start + to - (block ? 2 : 0)]),
+        });
+        for (const token of tokens) {
+            const label = token.type.label;
+            if (label === 'template')
+                ranges.push([start + token.start, start + token.end]);
+            else if (label === 'string')
+                ranges.push([start + token.start + 1, start + token.end - 1]);
+            else if (label === 'regexp') {
+                const raw = content.slice(start + token.start, start + token.end);
+                ranges.push([start + token.start + 1, start + token.start + raw.lastIndexOf('/')]);
+            }
+            else if (OPENS.has(label))
+                depth++;
+            else if (label === '}' && depth-- === 0)
+                return { ranges, end: start + token.end };
+        }
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError && 'pos' in error && typeof error.pos === 'number')) {
+            return { ranges, end: content.length };
+        }
+        const pos = start + error.pos;
+        if (!error.message.startsWith('Unterminated string'))
+            return { ranges, end: pos };
+        const lineEnd = content.indexOf('\n', pos);
+        ranges.push([pos + 1, lineEnd === -1 ? content.length : lineEnd]);
+    }
+    return { ranges, end: content.length };
+};
+const expressionRanges = (content) => {
+    const ranges = [];
+    for (let index = 0; index < content.length; index++) {
+        const char = content[index];
+        if (char === '\\')
+            index++;
+        else if (char === '{') {
+            const expression = maskExpression(content, index + 1);
+            ranges.push(...expression.ranges);
+            index = expression.end - 1;
+        }
+    }
+    return ranges;
+};
+const attributeRanges = (content) => [...content.matchAll(JSX_TAG)].flatMap(({ index, 0: tag }) => [...tag.matchAll(ATTR_VALUE)].map(({ index: at, 0: value }) => [index + at + 1, index + at + value.length - 1]));
+const escapedTagRanges = (content) => [...content.matchAll(/\\[\s\S]/g)].flatMap(({ index, 0: escape }) => escape === '\\<' ? [[index + 1, index + 2]] : []);
+export const maskNonMarkup = (content) => maskWith(maskCode(content), [attributeRanges, escapedTagRanges, expressionRanges]);
+export const selectEdits = (edits) => {
+    const ordered = edits
+        .map((edit, index) => ({ edit, index }))
+        .sort((a, b) => b.edit.start - a.edit.start || b.edit.end - a.edit.end || b.index - a.index);
+    const selected = [];
+    let floor = Infinity;
+    for (const { edit } of ordered) {
+        if (edit.end > floor)
+            continue;
+        selected.push(edit);
+        floor = edit.start;
+    }
+    return selected;
+};
+export const applyEdits = (content, edits) => selectEdits(edits).reduce((result, edit) => result.slice(0, edit.start) + edit.text + result.slice(edit.end), content);
+const toOffset = (content, line, column = 1) => {
+    let offset = 0;
+    for (let current = 1; current < line; current++) {
+        const next = content.indexOf('\n', offset);
+        if (next === -1)
+            break;
+        offset = next + 1;
+    }
+    return offset + column - 1;
+};
+export const toPosition = (content, offset) => {
+    var _a, _b;
+    const before = content.slice(0, offset).split('\n');
+    return { line: before.length, column: ((_b = (_a = before.pop()) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + 1 };
+};
+const byStart = (a, b) => a.start - b.start;
+function toOriginal(edits, offset, inside) {
+    let delta = 0;
+    for (const edit of edits) {
+        const start = edit.start + delta;
+        if (inside === 'snap' ? offset < start : offset <= start)
+            break;
+        if (offset < start + edit.text.length)
+            return inside === 'snap' ? edit.start : undefined;
+        delta += edit.text.length - (edit.end - edit.start);
+    }
+    return offset - delta;
+}
+/** Maps an edit made against a later stage back to the original content, or undefined when it touches an earlier fix. */
+export const unmapEdit = (stages, index, edit) => {
+    let { start, end } = edit;
+    for (const { edits } of stages.slice(0, index).reverse()) {
+        const sorted = [...edits].sort(byStart);
+        const mappedStart = toOriginal(sorted, start, 'reject');
+        const mappedEnd = toOriginal(sorted, end, 'reject');
+        if (mappedStart === undefined || mappedEnd === undefined)
+            return undefined;
+        if (sorted.some((earlier) => earlier.start < mappedEnd && earlier.end > mappedStart)) {
+            return undefined;
+        }
+        start = mappedStart;
+        end = mappedEnd;
+    }
+    return { start, end, text: edit.text };
+};
+export const relocate = (stages, index, position) => {
+    const stage = stages[index];
+    const original = stages[0];
+    if (!stage || !original || position.line === undefined)
+        return {};
+    const offset = stages
+        .slice(0, index)
+        .reduceRight((current, { edits }) => toOriginal([...edits].sort(byStart), current, 'snap'), toOffset(stage.content, position.line, position.column));
+    const mapped = toPosition(original.content, offset);
+    return position.column === undefined ? { line: mapped.line } : mapped;
+};

package/bin/validate/output.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { addLog, ErrorLog } from '@mintlify/previewing';
+import { Box, Text } from 'ink';
+const location = ({ line, column }) => line ? `${line}${column ? `:${column}` : ''}` : '';
+const DiagnosticLine = ({ diagnostic }) => {
+    const at = location(diagnostic);
+    return (_jsxs(Text, { children: ['  ', diagnostic.severity === 'error' ? (_jsx(Text, { color: "red", children: "\u2717" })) : (_jsx(Text, { color: "yellow", children: "!" })), ' ', at && _jsxs(Text, { dimColor: true, children: [at, " "] }), _jsx(Text, { dimColor: true, children: diagnostic.rule }), " ", diagnostic.message, diagnostic.fix && _jsx(Text, { dimColor: true, children: " (fixable)" })] }));
+};
+const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`;
+export const logDiagnostics = (all) => {
+    var _a, _b;
+    const byFile = new Map();
+    for (const diagnostic of all) {
+        (_b = (_a = byFile.get(diagnostic.file)) === null || _a === void 0 ? void 0 : _a.push(diagnostic)) !== null && _b !== void 0 ? _b : byFile.set(diagnostic.file, [diagnostic]);
+    }
+    for (const [file, diagnostics] of byFile) {
+        addLog(_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: file }), diagnostics.map((diagnostic, index) => (_jsx(DiagnosticLine, { diagnostic: diagnostic }, index)))] }));
+    }
+    const errors = all.filter(({ severity }) => severity === 'error').length;
+    const warnings = all.length - errors;
+    if (errors > 0) {
+        addLog(_jsx(ErrorLog, { message: `${plural(errors, 'error')}${warnings > 0 ? `, ${plural(warnings, 'warning')}` : ''}` }));
+    }
+    else if (warnings > 0) {
+        addLog(_jsx(Text, { dimColor: true, children: plural(warnings, 'warning') }));
+    }
+    return errors > 0;
+};

package/bin/validate/rules/content/voidTags.js

@@ -0,0 +1,35 @@
+import { maskNonMarkup } from '../../mdx.js';
+const VOID_TAG = /<(br|hr|img)(?=[\s/>])((?:"[^"]*"|'[^']*'|\{[^{}]*\}|[^<>"'{}])*?)(\/?)>/g;
+export const voidTags = {
+    id: 'void-tags',
+    group: 'content',
+    severity: 'error',
+    scope: 'file',
+    description: "self-close void HTML tags (<br>, <hr>, <img>); MDX can't parse them unclosed",
+    raw: true,
+    check: ({ content }) => {
+        var _a, _b;
+        const masked = maskNonMarkup(content);
+        const issues = [];
+        for (const match of masked.matchAll(VOID_TAG)) {
+            if (match[3])
+                continue;
+            const start = match.index;
+            const end = start + match[0].length;
+            if (new RegExp(`^\\s*</${match[1]}\\s*>`).test(masked.slice(end)))
+                continue;
+            const before = content.slice(0, start).split('\n');
+            issues.push({
+                line: before.length,
+                column: ((_b = (_a = before.pop()) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + 1,
+                message: `<${match[1]}> must be self-closed`,
+                edit: {
+                    start,
+                    end,
+                    text: `${content.slice(start, end - 1).trimEnd()} />`,
+                },
+            });
+        }
+        return issues;
+    },
+};

package/bin/validate/rules/index.js

@@ -0,0 +1,3 @@
+import { voidTags } from './content/voidTags.js';
+/** Every check mint validate runs, in report order. */
+export const RULES = [voidTags];

package/bin/validate/rules/parseError.js

@@ -0,0 +1,7 @@
+/** The engine's built-in diagnostic for files neither parser can parse; not a selectable rule. */
+export const PARSE_ERROR = {
+    id: 'parse-error',
+    group: 'content',
+    severity: 'error',
+    description: "files MDX can't parse; other checks skip them",
+};

package/bin/validate/site.js

@@ -0,0 +1,55 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { readSiteFiles } from './files.js';
+import { toPosition } from './mdx.js';
+const readVariables = (config) => {
+    try {
+        const { variables } = JSON.parse(config);
+        return variables && typeof variables === 'object'
+            ? variables
+            : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+/** Lists the site's pages and snippets; locate reads files from disk on demand. */
+export const loadSite = (baseDir_1, _a) => __awaiter(void 0, [baseDir_1, _a], void 0, function* (baseDir, { selected, localSchema }) {
+    const files = yield readSiteFiles(baseDir);
+    const byPath = new Map();
+    const configFile = existsSync(path.join(baseDir, 'docs.json')) ? 'docs.json' : 'mint.json';
+    const read = (file) => {
+        var _a;
+        if (!byPath.has(file)) {
+            try {
+                byPath.set(file, readFileSync(path.join(baseDir, file), 'utf-8'));
+            }
+            catch (_b) {
+                byPath.set(file, '');
+            }
+        }
+        return (_a = byPath.get(file)) !== null && _a !== void 0 ? _a : '';
+    };
+    return {
+        baseDir,
+        files,
+        selected,
+        configFile,
+        variables: readVariables(read(configFile)),
+        localSchema,
+        locate: (file, text) => {
+            const content = read(file);
+            const offset = text ? content.indexOf(text) : -1;
+            return offset === -1 ? {} : toPosition(content, offset);
+        },
+    };
+});

package/bin/validate/types.js

@@ -0,0 +1 @@
+export const GROUPS = ['content', 'nav', 'config', 'openapi'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintlify/cli",
-  "version": "4.0.1732",
+  "version": "4.0.1734",
   "description": "The Mintlify CLI",
   "engines": {
     "node": ">=18.0.0"
@@ -45,12 +45,12 @@
   },
   "dependencies": {
     "@inquirer/prompts": "7.9.0",
-    "@mintlify/common": "1.0.1304",
-    "@mintlify/link-rot": "3.0.1531",
+    "@mintlify/common": "1.0.1306",
+    "@mintlify/link-rot": "3.0.1533",
     "@mintlify/models": "0.0.379",
-    "@mintlify/og": "0.0.103",
-    "@mintlify/prebuild": "1.0.1470",
-    "@mintlify/previewing": "4.0.1549",
+    "@mintlify/og": "0.0.105",
+    "@mintlify/prebuild": "1.0.1472",
+    "@mintlify/previewing": "4.0.1551",
     "@mintlify/validation": "0.1.944",
     "adm-zip": "0.6.0",
     "chalk": "5.2.0",
@@ -82,7 +82,7 @@
     "keytar": "7.9.0"
   },
   "devDependencies": {
-    "@mintlify/editor": "0.0.576",
+    "@mintlify/editor": "0.0.578",
     "@mintlify/ts-config": "2.0.2",
     "@tsconfig/recommended": "1.0.2",
     "@types/detect-port": "1.3.2",
@@ -101,5 +101,5 @@
     "vitest": "2.1.9",
     "vitest-mock-process": "1.0.4"
   },
-  "gitHead": "c92cc428580477a5168c2a891b2038e2670861a2"
+  "gitHead": "ae7819bfab79f6c765d39aed34bf33363f4be72a"
 }