@mintlify/cli 4.0.1315 → 4.0.1317

package/bin/deslop/index.js

@@ -0,0 +1,242 @@
+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, ErrorLog, SpinnerLog, removeLastLog } from '@mintlify/previewing';
+import chalk from 'chalk';
+import { Text } from 'ink';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { CMD_EXEC_PATH, terminate } from '../helpers.js';
+import { trackEvent } from '../telemetry/track.js';
+import { checkPages } from './client.js';
+import { resolveChangedFiles, resolveExplicitFiles } from './resolveFiles.js';
+import { normalizeWhitespace, summarizeWhitespace } from './whitespace.js';
+function fixWhitespacePass(files, apply) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const changes = [];
+        for (const file of files) {
+            const fullPath = path.join(CMD_EXEC_PATH, file);
+            const content = yield fs.readFile(fullPath, 'utf-8');
+            const report = normalizeWhitespace(content);
+            const summary = summarizeWhitespace(report.counts);
+            if (!report.changed || !summary)
+                continue;
+            if (apply)
+                yield fs.writeFile(fullPath, report.fixed);
+            changes.push({ file, summary });
+        }
+        return changes;
+    });
+}
+const identity = (text) => text;
+const colorPalette = { green: chalk.green, red: chalk.red, dim: chalk.dim };
+const plainPalette = { green: identity, red: identity, dim: identity };
+function resolveFormat(argv) {
+    if (argv.format === 'table' || argv.format === 'plain' || argv.format === 'json')
+        return argv.format;
+    return 'table';
+}
+function output(format, text) {
+    if (format === 'table') {
+        addLog(_jsx(Text, { children: text }));
+    }
+    else {
+        process.stdout.write(text + '\n');
+    }
+}
+function requireSubdomain(subdomain) {
+    if (!subdomain) {
+        throw new Error('No subdomain set. Pass --subdomain, or run `mint config set subdomain <name>`.');
+    }
+    return subdomain;
+}
+function flaggedFraction(response) {
+    return response.fractionAi + response.fractionAiAssisted;
+}
+// A fully-human page (fraction 0) never fails, even at --threshold 0.
+function isFailing(fraction, threshold) {
+    return fraction > 0 && fraction >= threshold;
+}
+function truncateText(text, max = 100) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > max ? `${flat.slice(0, max)}…` : flat;
+}
+function renderResult(result, threshold, palette) {
+    var _a;
+    if ('error' in result) {
+        return [`${palette.red('✗')} ${result.file} — ${palette.red(result.error)}`];
+    }
+    const response = result.response;
+    if (response.skipped !== null) {
+        return [`${palette.dim('○')} ${result.file} — ${palette.dim(`skipped (${response.skipped})`)}`];
+    }
+    const fraction = flaggedFraction(response);
+    const failing = isFailing(fraction, threshold);
+    const icon = failing ? palette.red('✗') : palette.green('✓');
+    const percent = Math.round(fraction * 100);
+    const lines = [`${icon} ${result.file} — ${response.predictionShort} (${percent}% AI-written)`];
+    if (!failing)
+        return lines;
+    for (const window of response.windows) {
+        lines.push(`  L${window.startLine}–${window.endLine} [${window.label} ${window.aiAssistanceScore.toFixed(2)}]`);
+        lines.push(`  ${palette.dim(truncateText(window.text))}`);
+        for (const rewrite of (_a = window.rewrites) !== null && _a !== void 0 ? _a : []) {
+            lines.push(`    ↻ ${rewrite.text}`);
+            lines.push(`      ${palette.dim(rewrite.rationale)}`);
+        }
+    }
+    return lines;
+}
+function summarize(results, threshold) {
+    const summary = {
+        checked: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        creditsCharged: 0,
+        errors: 0,
+    };
+    for (const result of results) {
+        if ('error' in result) {
+            summary.errors += 1;
+            continue;
+        }
+        summary.creditsCharged += result.response.creditsCharged;
+        if (result.response.skipped !== null) {
+            summary.skipped += 1;
+            continue;
+        }
+        summary.checked += 1;
+        if (isFailing(flaggedFraction(result.response), threshold)) {
+            summary.failed += 1;
+        }
+        else {
+            summary.passed += 1;
+        }
+    }
+    return summary;
+}
+function renderSummaryLine(summary, palette) {
+    const parts = [
+        `${summary.checked} checked`,
+        palette.green(`${summary.passed} passed`),
+        summary.failed > 0 ? palette.red(`${summary.failed} failed`) : `${summary.failed} failed`,
+        palette.dim(`${summary.skipped} skipped`),
+        `${summary.creditsCharged} ${summary.creditsCharged === 1 ? 'credit' : 'credits'} used`,
+    ];
+    if (summary.errors > 0) {
+        parts.push(palette.red(`${summary.errors} ${summary.errors === 1 ? 'error' : 'errors'}`));
+    }
+    return parts.join(' · ');
+}
+export const deslopHandler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const format = resolveFormat(argv);
+    let spinnerAdded = false;
+    const threshold = typeof argv.threshold === 'number' ? argv.threshold : 0.5;
+    try {
+        const subdomain = requireSubdomain(argv.subdomain);
+        const fileArgs = ((_a = argv.files) !== null && _a !== void 0 ? _a : []).map(String).filter(Boolean);
+        const files = fileArgs.length > 0
+            ? yield resolveExplicitFiles(CMD_EXEC_PATH, fileArgs)
+            : yield resolveChangedFiles(CMD_EXEC_PATH);
+        if (files.length === 0) {
+            if (format === 'json') {
+                process.stderr.write('No changed docs pages to check.\n');
+                output(format, JSON.stringify({
+                    threshold,
+                    results: [],
+                    summary: {
+                        checked: 0,
+                        passed: 0,
+                        failed: 0,
+                        skipped: 0,
+                        errors: 0,
+                        creditsCharged: 0,
+                    },
+                }, null, 2));
+            }
+            else {
+                output(format, 'No changed docs pages to check.');
+            }
+            yield terminate(0);
+            return;
+        }
+        const whitespaceChanges = argv.fixWhitespace ? yield fixWhitespacePass(files, true) : [];
+        const progressMessage = `Checking ${files.length} ${files.length === 1 ? 'page' : 'pages'} for AI-sounding prose...`;
+        if (format === 'table') {
+            addLog(_jsx(SpinnerLog, { message: progressMessage }));
+            spinnerAdded = true;
+        }
+        else {
+            process.stderr.write(progressMessage + '\n');
+        }
+        const pages = yield Promise.all(files.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                path: file,
+                content: yield fs.readFile(path.join(CMD_EXEC_PATH, file), 'utf-8'),
+            });
+        })));
+        const results = yield checkPages(subdomain, pages);
+        if (spinnerAdded) {
+            removeLastLog();
+            spinnerAdded = false;
+        }
+        const summary = summarize(results, threshold);
+        void trackEvent('cli.deslop.executed', {
+            fileCount: files.length,
+            flaggedCount: summary.failed,
+            format,
+        });
+        if (format === 'json') {
+            output(format, JSON.stringify({
+                threshold,
+                results: results.map((result) => 'error' in result ? { path: result.file, error: result.error } : result.response),
+                summary: {
+                    checked: summary.checked,
+                    passed: summary.passed,
+                    failed: summary.failed,
+                    skipped: summary.skipped,
+                    errors: summary.errors,
+                    creditsCharged: summary.creditsCharged,
+                },
+                whitespaceFixed: whitespaceChanges,
+            }, null, 2));
+        }
+        else {
+            const palette = format === 'table' ? colorPalette : plainPalette;
+            const lines = [];
+            for (const change of whitespaceChanges) {
+                lines.push(`${palette.green('⇥')} ${change.file} — whitespace fixed (${change.summary})`);
+            }
+            if (whitespaceChanges.length)
+                lines.push('');
+            for (const result of results) {
+                lines.push(...renderResult(result, threshold, palette));
+            }
+            lines.push('');
+            lines.push(renderSummaryLine(summary, palette));
+            output(format, lines.join('\n'));
+        }
+        yield terminate(summary.failed > 0 || summary.errors > 0 ? 1 : 0);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'unknown error';
+        if (format === 'table') {
+            if (spinnerAdded)
+                removeLastLog();
+            addLog(_jsx(ErrorLog, { message: message }));
+        }
+        else {
+            process.stderr.write(`Error: ${message}\n`);
+        }
+        yield terminate(1);
+    }
+});

package/bin/deslop/resolveFiles.js

@@ -0,0 +1,186 @@
+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 { categorizeFilePaths, getMintIgnore } from '@mintlify/prebuild';
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const GLOB_CHARS = /[*?]/;
+const DOCS_FILE = /\.mdx?$/i;
+const REGEX_SPECIAL = /[.+^${}()|\\[\]]/;
+const SKIPPED_DIRS = new Set(['.git', 'node_modules']);
+function toPosix(filePath) {
+    return filePath.split(path.sep).join('/');
+}
+function normalizeArg(arg) {
+    return toPosix(arg).replace(/^\.\//, '');
+}
+function globToRegExp(pattern) {
+    let source = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const char = pattern[i];
+        if (char === '*') {
+            if (pattern[i + 1] === '*') {
+                if (pattern[i + 2] === '/') {
+                    source += '(?:[^/]+/)*';
+                    i += 3;
+                }
+                else {
+                    source += '.*';
+                    i += 2;
+                }
+            }
+            else {
+                source += '[^/]*';
+                i += 1;
+            }
+        }
+        else if (char === '?') {
+            source += '[^/]';
+            i += 1;
+        }
+        else {
+            source += REGEX_SPECIAL.test(char) ? `\\${char}` : char;
+            i += 1;
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+function exists(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield fs.access(filePath);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function isFile(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return (yield fs.stat(filePath)).isFile();
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function walk(baseDir_1) {
+    return __awaiter(this, arguments, void 0, function* (baseDir, dir = '') {
+        const entries = yield fs.readdir(path.join(baseDir, dir), { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            if (SKIPPED_DIRS.has(entry.name))
+                continue;
+            const rel = dir ? `${dir}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                files.push(...(yield walk(baseDir, rel)));
+            }
+            else {
+                files.push(rel);
+            }
+        }
+        return files;
+    });
+}
+export function resolveExplicitFiles(baseDir, args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let allFiles = null;
+        const matched = [];
+        const unmatched = [];
+        for (const arg of args) {
+            const pattern = normalizeArg(arg);
+            if (GLOB_CHARS.test(pattern)) {
+                allFiles = allFiles !== null && allFiles !== void 0 ? allFiles : (yield walk(baseDir));
+                const regex = globToRegExp(pattern);
+                const hits = allFiles.filter((file) => DOCS_FILE.test(file) && regex.test(file)).sort();
+                if (hits.length === 0) {
+                    unmatched.push(arg);
+                }
+                else {
+                    matched.push(...hits);
+                }
+            }
+            else if (yield isFile(path.join(baseDir, pattern))) {
+                matched.push(pattern);
+            }
+            else {
+                unmatched.push(arg);
+            }
+        }
+        if (unmatched.length > 0) {
+            throw new Error(`No matching files for: ${unmatched.join(', ')} (globs match .md and .mdx files)`);
+        }
+        return [...new Set(matched)];
+    });
+}
+function runGit(args, cwd) {
+    return new Promise((resolve, reject) => {
+        execFile('git', args, { cwd }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
+function parseGitLines(stdout) {
+    return stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export function resolveChangedFiles(baseDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield runGit(['rev-parse', '--is-inside-work-tree'], baseDir);
+        }
+        catch (_a) {
+            throw new Error('Not a git repository, so changed pages cannot be detected. Pass explicit paths: `mint deslop <files..>`.');
+        }
+        let diff;
+        let untracked;
+        try {
+            [diff, untracked] = yield Promise.all([
+                runGit(['-c', 'core.quotePath=false', 'diff', '--name-only', '--relative', 'HEAD'], baseDir),
+                runGit(['-c', 'core.quotePath=false', 'ls-files', '--others', '--exclude-standard'], baseDir),
+            ]);
+        }
+        catch (_b) {
+            throw new Error('Could not detect changed pages (does the repository have any commits?). Pass explicit paths: `mint deslop <files..>`.');
+        }
+        const candidates = [...new Set([...parseGitLines(diff), ...parseGitLines(untracked)])]
+            .map(normalizeArg)
+            .filter((file) => DOCS_FILE.test(file));
+        const existing = [];
+        for (const file of candidates) {
+            if (yield exists(path.join(baseDir, file)))
+                existing.push(file);
+        }
+        if (existing.length === 0)
+            return [];
+        if (!(yield exists(path.join(baseDir, 'docs.json')))) {
+            return existing;
+        }
+        try {
+            const mintIgnore = yield getMintIgnore(baseDir);
+            const { contentFilenames } = yield categorizeFilePaths(baseDir, mintIgnore);
+            const contentSet = new Set(contentFilenames.map((file) => toPosix(file).replace(/^\//, '')));
+            return existing.filter((file) => contentSet.has(file));
+        }
+        catch (_c) {
+            // docs.json is present but its navigation could not be resolved. Fail closed
+            // rather than sending possibly-ignored files to the credit-consuming API.
+            throw new Error('Could not read docs.json to determine which pages to check. Pass explicit paths: `mint deslop <files..>`.');
+        }
+    });
+}

package/bin/deslop/types.js

@@ -0,0 +1 @@
+export {};

package/bin/deslop/whitespace.js

@@ -0,0 +1,144 @@
+// Unusual space characters that should read as a normal space.
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+// Zero-width and BOM characters that should be removed outright.
+const ZERO_WIDTH = /[\u200B-\u200D\u2060\uFEFF]/g;
+const FENCE = /^(\s*)(`{3,}|~{3,})/;
+// Splits a line so odd indices are inline-code spans (left untouched).
+const INLINE_CODE = /(`+[^`]*`+)/;
+function isFrontmatterFence(line, index) {
+    return index === 0 && line.trim() === '---';
+}
+/**
+ * Normalize prose whitespace in an MDX document without touching the bytes of
+ * fenced code blocks or YAML frontmatter, where spacing is significant.
+ */
+export function normalizeWhitespace(content) {
+    var _a, _b, _c;
+    const counts = {
+        trailing: 0,
+        blankRuns: 0,
+        unicodeSpaces: 0,
+        zeroWidth: 0,
+        spaces: 0,
+        finalNewline: false,
+    };
+    const lines = content.split('\n');
+    const out = [];
+    const isProtected = [];
+    let inFence = false;
+    let fenceMarker = '';
+    let inFrontmatter = false;
+    const pushProtected = (line) => {
+        out.push(line);
+        isProtected.push(true);
+    };
+    for (const [index, rawLine] of lines.entries()) {
+        if (isFrontmatterFence(rawLine, index)) {
+            inFrontmatter = true;
+            pushProtected(rawLine);
+            continue;
+        }
+        if (inFrontmatter) {
+            pushProtected(rawLine);
+            if (rawLine.trim() === '---')
+                inFrontmatter = false;
+            continue;
+        }
+        const fence = rawLine.match(FENCE);
+        if (fence) {
+            const marker = (_a = fence[2]) !== null && _a !== void 0 ? _a : '';
+            if (!inFence) {
+                inFence = true;
+                fenceMarker = marker;
+            }
+            else if (marker[0] === fenceMarker[0] && marker.length >= fenceMarker.length) {
+                inFence = false;
+            }
+            pushProtected(rawLine);
+            continue;
+        }
+        if (inFence) {
+            pushProtected(rawLine);
+            continue;
+        }
+        let line = rawLine;
+        // Separate a trailing CR so CRLF files still get their trailing whitespace
+        // stripped (and keep the CR so line endings are preserved).
+        const cr = line.endsWith('\r') ? '\r' : '';
+        if (cr)
+            line = line.slice(0, -1);
+        // Apply substitutions only outside inline-code spans (odd split indices),
+        // so backticked code keeps its exact spacing.
+        line = line
+            .split(INLINE_CODE)
+            .map((seg, i) => {
+            if (i % 2 === 1)
+                return seg;
+            const uni = seg.match(UNICODE_SPACES);
+            if (uni)
+                counts.unicodeSpaces += uni.length;
+            seg = seg.replace(UNICODE_SPACES, ' ');
+            const zw = seg.match(ZERO_WIDTH);
+            if (zw)
+                counts.zeroWidth += zw.length;
+            return seg.replace(ZERO_WIDTH, '');
+        })
+            .join('');
+        const trimmed = line.replace(/[ \t]+$/, '');
+        if (trimmed !== line)
+            counts.trailing += 1;
+        line = trimmed;
+        // Collapse runs of internal spaces (outside inline code), preserving leading indentation.
+        const leading = (_c = (_b = line.match(/^[ \t]*/)) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : '';
+        const body = line.slice(leading.length);
+        const collapsed = body
+            .split(INLINE_CODE)
+            .map((seg, i) => (i % 2 === 1 ? seg : seg.replace(/ {2,}/g, ' ')))
+            .join('');
+        if (collapsed !== body)
+            counts.spaces += 1;
+        line = leading + collapsed + cr;
+        out.push(line);
+        isProtected.push(false);
+    }
+    // Collapse runs of 2 or more consecutive blank lines down to a single blank
+    // line, but never inside protected regions (code fences, frontmatter).
+    const collapsed = [];
+    let blankRun = 0;
+    for (const [index, line] of out.entries()) {
+        if (!isProtected[index] && line.trim() === '') {
+            blankRun += 1;
+            if (blankRun <= 1)
+                collapsed.push(line);
+            continue;
+        }
+        if (blankRun > 1)
+            counts.blankRuns += 1;
+        blankRun = 0;
+        collapsed.push(line);
+    }
+    if (blankRun > 1)
+        counts.blankRuns += 1;
+    let fixed = collapsed.join('\n').replace(/\n+$/, '');
+    if (content.length > 0) {
+        counts.finalNewline = !content.endsWith('\n') || content.endsWith('\n\n');
+        fixed += '\n';
+    }
+    return { fixed, changed: fixed !== content, counts };
+}
+export function summarizeWhitespace(counts) {
+    const parts = [];
+    if (counts.trailing)
+        parts.push(`${counts.trailing} trailing`);
+    if (counts.blankRuns)
+        parts.push(`${counts.blankRuns} blank-line runs`);
+    if (counts.unicodeSpaces)
+        parts.push(`${counts.unicodeSpaces} unicode spaces`);
+    if (counts.zeroWidth)
+        parts.push(`${counts.zeroWidth} zero-width chars`);
+    if (counts.spaces)
+        parts.push(`${counts.spaces} collapsed spaces`);
+    if (counts.finalNewline)
+        parts.push('final newline');
+    return parts.length ? parts.join(', ') : null;
+}