@mintlify/cli 4.0.1409 → 4.0.1411

package/src/deslop/index.tsx

@@ -1,286 +0,0 @@
-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 type { DeslopCheckedResponse, DeslopFileResult } from './types.js';
-import { normalizeWhitespace, summarizeWhitespace } from './whitespace.js';
-
-type OutputFormat = 'table' | 'plain' | 'json';
-
-export type DeslopArgs = {
-  files?: (string | number)[];
-  format?: string;
-  subdomain?: string;
-  threshold?: number;
-  fixWhitespace?: boolean;
-};
-
-async function fixWhitespacePass(
-  files: string[],
-  apply: boolean
-): Promise<{ file: string; summary: string }[]> {
-  const changes: { file: string; summary: string }[] = [];
-  for (const file of files) {
-    const fullPath = path.join(CMD_EXEC_PATH, file);
-    const content = await fs.readFile(fullPath, 'utf-8');
-    const report = normalizeWhitespace(content);
-    const summary = summarizeWhitespace(report.counts);
-    if (!report.changed || !summary) continue;
-    if (apply) await fs.writeFile(fullPath, report.fixed);
-    changes.push({ file, summary });
-  }
-  return changes;
-}
-
-type Paint = (text: string) => string;
-
-type Palette = { green: Paint; red: Paint; dim: Paint };
-
-const identity: Paint = (text) => text;
-
-const colorPalette: Palette = { green: chalk.green, red: chalk.red, dim: chalk.dim };
-const plainPalette: Palette = { green: identity, red: identity, dim: identity };
-
-function resolveFormat(argv: { format?: string }): OutputFormat {
-  if (argv.format === 'table' || argv.format === 'plain' || argv.format === 'json')
-    return argv.format;
-  return 'table';
-}
-
-function output(format: OutputFormat, text: string) {
-  if (format === 'table') {
-    addLog(<Text>{text}</Text>);
-  } else {
-    process.stdout.write(text + '\n');
-  }
-}
-
-function requireSubdomain(subdomain: string | undefined): string {
-  if (!subdomain) {
-    throw new Error(
-      'No subdomain set. Pass --subdomain, or run `mint config set subdomain <name>`.'
-    );
-  }
-  return subdomain;
-}
-
-function flaggedFraction(response: DeslopCheckedResponse): number {
-  return response.fractionAi + response.fractionAiAssisted;
-}
-
-// A fully-human page (fraction 0) never fails, even at --threshold 0.
-function isFailing(fraction: number, threshold: number): boolean {
-  return fraction > 0 && fraction >= threshold;
-}
-
-function truncateText(text: string, max = 100): string {
-  const flat = text.replace(/\s+/g, ' ').trim();
-  return flat.length > max ? `${flat.slice(0, max)}…` : flat;
-}
-
-function renderResult(result: DeslopFileResult, threshold: number, palette: Palette): string[] {
-  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 window.rewrites ?? []) {
-      lines.push(`    ↻ ${rewrite.text}`);
-      lines.push(`      ${palette.dim(rewrite.rationale)}`);
-    }
-  }
-  return lines;
-}
-
-type Summary = {
-  checked: number;
-  passed: number;
-  failed: number;
-  skipped: number;
-  creditsCharged: number;
-  errors: number;
-};
-
-function summarize(results: DeslopFileResult[], threshold: number): Summary {
-  const summary: 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: Summary, palette: Palette): string {
-  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 = async (argv: DeslopArgs) => {
-  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 = (argv.files ?? []).map(String).filter(Boolean);
-    const files =
-      fileArgs.length > 0
-        ? await resolveExplicitFiles(CMD_EXEC_PATH, fileArgs)
-        : await 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.');
-      }
-      await terminate(0);
-      return;
-    }
-
-    const whitespaceChanges = argv.fixWhitespace ? await fixWhitespacePass(files, true) : [];
-
-    const progressMessage = `Checking ${files.length} ${files.length === 1 ? 'page' : 'pages'} for AI-sounding prose...`;
-    if (format === 'table') {
-      addLog(<SpinnerLog message={progressMessage} />);
-      spinnerAdded = true;
-    } else {
-      process.stderr.write(progressMessage + '\n');
-    }
-
-    const pages = await Promise.all(
-      files.map(async (file) => ({
-        path: file,
-        content: await fs.readFile(path.join(CMD_EXEC_PATH, file), 'utf-8'),
-      }))
-    );
-    const results = await 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: string[] = [];
-      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'));
-    }
-
-    await 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(<ErrorLog message={message} />);
-    } else {
-      process.stderr.write(`Error: ${message}\n`);
-    }
-    await terminate(1);
-  }
-};

package/src/deslop/types.ts

@@ -1,39 +0,0 @@
-export type PredictionShort = 'AI' | 'AI-Assisted' | 'Human' | 'Mixed';
-
-export interface Rewrite {
-  text: string;
-  rationale: string;
-}
-
-export interface DeslopWindow {
-  text: string;
-  label: string;
-  aiAssistanceScore: number;
-  confidence: string | number;
-  startLine: number;
-  endLine: number;
-  rewrites?: Rewrite[];
-}
-
-export interface DeslopCheckedResponse {
-  path: string;
-  skipped: null;
-  predictionShort: PredictionShort;
-  fractionAi: number;
-  fractionAiAssisted: number;
-  fractionHuman: number;
-  windows: DeslopWindow[];
-  creditsCharged: number;
-}
-
-export interface DeslopSkippedResponse {
-  path: string;
-  skipped: string;
-  creditsCharged: number;
-}
-
-export type DeslopResponse = DeslopCheckedResponse | DeslopSkippedResponse;
-
-export type DeslopFileResult =
-  | { file: string; response: DeslopResponse }
-  | { file: string; error: string };

package/src/deslop/whitespace.ts

@@ -1,155 +0,0 @@
-export interface WhitespaceReport {
-  fixed: string;
-  changed: boolean;
-  counts: {
-    trailing: number;
-    blankRuns: number;
-    unicodeSpaces: number;
-    zeroWidth: number;
-    spaces: number;
-    finalNewline: boolean;
-  };
-}
-
-// 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: string, index: number): boolean {
-  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: string): WhitespaceReport {
-  const counts = {
-    trailing: 0,
-    blankRuns: 0,
-    unicodeSpaces: 0,
-    zeroWidth: 0,
-    spaces: 0,
-    finalNewline: false,
-  };
-
-  const lines = content.split('\n');
-  const out: string[] = [];
-  const isProtected: boolean[] = [];
-  let inFence = false;
-  let fenceMarker = '';
-  let inFrontmatter = false;
-
-  const pushProtected = (line: string) => {
-    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 = fence[2] ?? '';
-      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 = line.match(/^[ \t]*/)?.[0] ?? '';
-    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: string[] = [];
-  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: WhitespaceReport['counts']): string | null {
-  const parts: string[] = [];
-  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;
-}