@mintlify/cli 4.0.1409 → 4.0.1411

package/__test__/brokenLinks.test.ts

@@ -4,8 +4,8 @@ import { addLog, clearLogs } from '@mintlify/previewing';
 import path from 'node:path';
 import { mockProcessExit } from 'vitest-mock-process';
 
-import { resolveExplicitFiles } from '../src/deslop/resolveFiles.js';
 import { checkForMintJson, CMD_EXEC_PATH, findDocsRoot } from '../src/helpers.js';
+import { resolveExplicitFiles } from '../src/resolveFiles.js';
 import { runCommand } from './utils.js';
 
 vi.mock('@mintlify/previewing', async (importOriginal) => {
@@ -22,8 +22,7 @@ vi.mock('../src/helpers.js', async (importOriginal) => {
   };
 });
 
-vi.mock('../src/deslop/resolveFiles.js', () => ({
-  resolveChangedFiles: vi.fn(),
+vi.mock('../src/resolveFiles.js', () => ({
   resolveExplicitFiles: vi.fn(),
 }));
 

package/__test__/resolveFiles.test.ts

@@ -0,0 +1,70 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { resolveExplicitFiles } from '../src/resolveFiles.js';
+
+let baseDir: string;
+
+async function writeFixture(rel: string) {
+  const filePath = path.join(baseDir, rel);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, '# fixture\n');
+}
+
+beforeEach(async () => {
+  baseDir = await fs.mkdtemp(path.join(os.tmpdir(), 'resolve-files-test-'));
+});
+
+afterEach(async () => {
+  await fs.rm(baseDir, { recursive: true, force: true });
+});
+
+describe('resolveExplicitFiles', () => {
+  it('resolves literal paths', async () => {
+    await writeFixture('docs/a.mdx');
+    await expect(resolveExplicitFiles(baseDir, ['docs/a.mdx'])).resolves.toEqual(['docs/a.mdx']);
+  });
+
+  it('normalizes leading ./', async () => {
+    await writeFixture('docs/a.md');
+    await expect(resolveExplicitFiles(baseDir, ['./docs/a.md'])).resolves.toEqual(['docs/a.md']);
+  });
+
+  it('errors listing paths that matched nothing', async () => {
+    await writeFixture('docs/a.mdx');
+    await expect(
+      resolveExplicitFiles(baseDir, ['docs/a.mdx', 'docs/missing.mdx', 'nope/*.mdx'])
+    ).rejects.toThrow('No matching files for: docs/missing.mdx, nope/*.mdx');
+  });
+
+  it('accepts existing literal paths regardless of extension', async () => {
+    await writeFixture('README.txt');
+    await expect(resolveExplicitFiles(baseDir, ['README.txt'])).resolves.toEqual(['README.txt']);
+  });
+
+  it('rejects a directory passed as a literal path', async () => {
+    await fs.mkdir(path.join(baseDir, 'docs'), { recursive: true });
+    await expect(resolveExplicitFiles(baseDir, ['docs'])).rejects.toThrow('No matching files');
+  });
+
+  it('expands globs recursively and keeps only docs files', async () => {
+    await writeFixture('docs/a.mdx');
+    await writeFixture('docs/nested/deep/b.mdx');
+    await writeFixture('docs/nested/notes.txt');
+    await writeFixture('top.md');
+
+    await expect(resolveExplicitFiles(baseDir, ['docs/**/*.mdx'])).resolves.toEqual([
+      'docs/a.mdx',
+      'docs/nested/deep/b.mdx',
+    ]);
+    await expect(resolveExplicitFiles(baseDir, ['*.md'])).resolves.toEqual(['top.md']);
+  });
+
+  it('dedupes overlapping literal and glob matches', async () => {
+    await writeFixture('docs/a.mdx');
+    await expect(resolveExplicitFiles(baseDir, ['docs/a.mdx', 'docs/*.mdx'])).resolves.toEqual([
+      'docs/a.mdx',
+    ]);
+  });
+});

package/bin/cli.js

@@ -21,8 +21,6 @@ import { comingSoon } from './comingSoon.js';
 import { setTelemetryEnabled } from './config.js';
 import { getConfigValue, setConfigValue, clearConfigValue } from './config.js';
 import { API_URL } from './constants.js';
-import { deslopHandler } from './deslop/index.js';
-import { resolveExplicitFiles } from './deslop/resolveFiles.js';
 import { formatHandler } from './format.js';
 import { CMD_EXEC_PATH, checkPort, checkNodeVersion, autoUpgradeIfNeeded, findDocsRoot, getVersions, isAI, suppressConsoleWarnings, terminate, } from './helpers.js';
 import { runIndexSetup } from './indexSetup/setup.js';
@@ -31,9 +29,9 @@ import { getAccessToken } from './keyring.js';
 import { login } from './login.js';
 import { logout } from './logout.js';
 import { mdxLinter } from './mdxLinter.js';
-import { subdomainMiddleware } from './middlewares/subdomainMiddleware.js';
 import { createTelemetryMiddleware } from './middlewares/telemetryMiddleware.js';
 import { checkOpenApiFile, getOpenApiFilenamesFromDocsConfig } from './openApiCheck.js';
+import { resolveExplicitFiles } from './resolveFiles.js';
 import { scoreHandler } from './score/index.js';
 import { signup } from './signup.js';
 import { status, getCliSubdomains } from './status.js';
@@ -546,42 +544,6 @@ export const cli = ({ packageName = 'mint' }) => {
     })
         .example('mint score', 'Run agent readiness checks on your default subdomain')
         .example('mint score docs.example.com', 'Run agent readiness checks on a URL'), scoreHandler)
-        .command('deslop [files..]', 'Detect AI-sounding prose and get humanization suggestions', (yargs) => yargs
-        .middleware(subdomainMiddleware)
-        .positional('files', {
-        type: 'string',
-        array: true,
-        description: 'Files or globs to check (defaults to git-changed pages)',
-    })
-        .option('format', {
-        type: 'string',
-        choices: ['table', 'plain', 'json'],
-        description: 'Output format',
-    })
-        .option('subdomain', {
-        type: 'string',
-        description: 'Documentation subdomain (default: mint config set subdomain)',
-    })
-        .option('threshold', {
-        type: 'number',
-        default: 0.5,
-        description: 'Fail a page when its AI-written fraction meets this value (0-1)',
-    })
-        .option('fix-whitespace', {
-        type: 'boolean',
-        default: false,
-        description: 'Normalize prose whitespace in the checked files (skips code and frontmatter)',
-    })
-        .check((argv) => {
-        if (typeof argv.threshold === 'number' &&
-            (argv.threshold < 0 || argv.threshold > 1 || Number.isNaN(argv.threshold))) {
-            throw new Error('--threshold must be a number between 0 and 1');
-        }
-        return true;
-    })
-        .example('mint deslop', 'Check git-changed pages for AI-sounding prose')
-        .example('mint deslop docs/guide.mdx', 'Check a specific page')
-        .example('mint deslop "docs/**/*.mdx" --format json', 'Check pages by glob with agent-friendly JSON output'), deslopHandler)
         .command('format', 'Format MDX files in the current directory', (yargs) => yargs
         .usage('usage: mint format')
         .example('mint format', 'format all MDX files in the current directory'), formatHandler)

package/bin/{deslop/resolveFiles.js → resolveFiles.js}

@@ -7,8 +7,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 = /[*?]/;
@@ -53,17 +51,6 @@ function globToRegExp(pattern) {
     }
     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 {
@@ -123,64 +110,3 @@ export function resolveExplicitFiles(baseDir, args) {
         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..>`.');
-        }
-    });
-}