@mintlify/cli 4.0.1812 → 4.1.1

package/src/mdxAccessibility.ts

@@ -1,134 +0,0 @@
-import { coreRemark } from '@mintlify/common';
-import { categorizeFilePaths, getMintIgnore } from '@mintlify/prebuild';
-import fs from 'fs';
-import type { Root, Text } from 'mdast';
-import type { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
-import path from 'path';
-import type { Node } from 'unist';
-import { visit } from 'unist-util-visit';
-
-export interface AccessibilityFixAttribute {
-  filePath: string;
-  line?: number;
-  column?: number;
-  element: 'img' | 'video' | 'a';
-  tagName: string;
-}
-
-export interface MdxAccessibilityResult {
-  missingAltAttributes: AccessibilityFixAttribute[];
-  totalFiles: number;
-  filesWithIssues: number;
-}
-
-const checkAltAttributes = (filePath: string, content: string): AccessibilityFixAttribute[] => {
-  const issues: AccessibilityFixAttribute[] = [];
-
-  const visitElements = () => {
-    return (tree: Root) => {
-      visit(tree, (node) => {
-        if (node.type === 'image') {
-          if (!node.alt || node.alt.trim() === '') {
-            issues.push({
-              filePath,
-              line: node.position?.start.line,
-              column: node.position?.start.column,
-              element: 'img',
-              tagName: 'image (markdown)',
-            });
-          }
-          return;
-        }
-
-        const mdxJsxElement = node as MdxJsxFlowElement;
-        if (mdxJsxElement.name === 'img' || mdxJsxElement.name === 'video') {
-          const altAttrIndex = mdxJsxElement.attributes.findIndex(
-            (attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'alt'
-          );
-
-          const altAttribute = mdxJsxElement.attributes[altAttrIndex];
-          const hasValidAlt =
-            altAttribute &&
-            typeof altAttribute.value === 'string' &&
-            altAttribute.value.trim() !== '';
-
-          if (!hasValidAlt) {
-            issues.push({
-              filePath,
-              line: node.position?.start.line,
-              column: node.position?.start.column,
-              element: mdxJsxElement.name,
-              tagName: mdxJsxElement.name,
-            });
-          }
-        } else if (mdxJsxElement.name === 'a') {
-          const hasTextContent = (children: Node[]): boolean => {
-            return children.some((child) => {
-              if (child.type === 'text') {
-                const textNode = child as Text;
-                return textNode.value.trim() !== '';
-              }
-              if ('children' in child && Array.isArray(child.children)) {
-                return hasTextContent(child.children as Node[]);
-              }
-              return false;
-            });
-          };
-
-          if (!hasTextContent(mdxJsxElement.children as Node[])) {
-            issues.push({
-              filePath,
-              line: node.position?.start.line,
-              column: node.position?.start.column,
-              element: 'a',
-              tagName: '<a>',
-            });
-          }
-        }
-      });
-      return tree;
-    };
-  };
-
-  try {
-    const stripped = content.replace(/^( {0,3}#{1,6}\s+.+?)\s*\{#[^}]+\}\s*$/gm, '$1');
-    coreRemark().use(visitElements).processSync(stripped);
-  } catch (error) {
-    console.warn(`Warning: Could not parse ${filePath}: ${error}`);
-  }
-
-  return issues;
-};
-
-export const checkMdxAccessibility = async (
-  baseDir: string = process.cwd()
-): Promise<MdxAccessibilityResult> => {
-  const mintIgnore = await getMintIgnore(baseDir);
-  const { contentFilenames } = await categorizeFilePaths(baseDir, mintIgnore);
-  const mdxFiles: string[] = [];
-  for (const file of contentFilenames) {
-    mdxFiles.push(path.join(baseDir, file));
-  }
-  const allIssues: AccessibilityFixAttribute[] = [];
-  const filesWithIssues = new Set<string>();
-
-  for (const filePath of mdxFiles) {
-    try {
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const issues = checkAltAttributes(filePath, content);
-
-      if (issues.length > 0) {
-        allIssues.push(...issues);
-        filesWithIssues.add(filePath);
-      }
-    } catch (error) {
-      console.warn(`Warning: Could not read file ${filePath}: ${error}`);
-    }
-  }
-
-  return {
-    missingAltAttributes: allIssues,
-    totalFiles: mdxFiles.length,
-    filesWithIssues: filesWithIssues.size,
-  };
-};

package/src/mdxLinter.tsx

@@ -1,88 +0,0 @@
-import { addLog, ErrorLog, SuccessLog } from '@mintlify/previewing';
-import { Text } from 'ink';
-import path from 'path';
-
-import { TerminateCode } from './accessibilityCheck.js';
-import { checkMdxAccessibility, type AccessibilityFixAttribute } from './mdxAccessibility.js';
-
-export const mdxLinter = async (): Promise<TerminateCode> => {
-  try {
-    addLog(
-      <Text bold color="cyan">
-        Checking mdx files for accessibility issues...
-      </Text>
-    );
-
-    const results = await checkMdxAccessibility();
-
-    if (results.missingAltAttributes.length === 0) {
-      addLog(<SuccessLog message="no accessibility issues found" />);
-      addLog(
-        <Text>
-          Checked {results.totalFiles} MDX files - all images and videos have alt attributes.
-        </Text>
-      );
-      return 0;
-    }
-
-    const issuesByFile: Record<string, AccessibilityFixAttribute[]> = {};
-    results.missingAltAttributes.forEach((issue) => {
-      if (!issuesByFile[issue.filePath]) {
-        issuesByFile[issue.filePath] = [];
-      }
-      issuesByFile[issue.filePath]?.push(issue);
-    });
-
-    addLog(
-      <Text bold color="red">
-        Found {results.missingAltAttributes.length} accessibility issues in{' '}
-        {results.filesWithIssues} files:
-      </Text>
-    );
-    addLog(<Text></Text>);
-
-    for (const [filePath, issues] of Object.entries(issuesByFile)) {
-      const relativePath = path.relative(process.cwd(), filePath);
-      addLog(<Text bold>{relativePath}:</Text>);
-
-      for (const issue of issues) {
-        const location =
-          issue.line && issue.column ? ` (line ${issue.line}, col ${issue.column})` : '';
-        if (issue.element === 'a') {
-          addLog(
-            <Text>
-              <Text color="red"> ✗</Text> Missing text attribute <Text bold>{issue.tagName}</Text>{' '}
-              element{location}
-            </Text>
-          );
-        } else {
-          addLog(
-            <Text>
-              <Text color="red"> ✗</Text> Missing alt attribute on <Text bold>{issue.tagName}</Text>{' '}
-              element{location}
-            </Text>
-          );
-        }
-      }
-      addLog(<Text></Text>);
-    }
-
-    addLog(
-      <Text color="yellow">
-        <Text bold>Recommendation:</Text> Add alt attributes to all images and videos for better
-        accessibility.
-      </Text>
-    );
-
-    return 1;
-  } catch (error) {
-    addLog(
-      <ErrorLog
-        message={`MDX accessibility check failed: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`}
-      />
-    );
-    return 1;
-  }
-};

package/src/middlewares/subdomainMiddleware.ts

@@ -1,20 +0,0 @@
-import type { ArgumentsCamelCase } from 'yargs';
-
-import { getConfigValue } from '../config.js';
-import { getAccessToken } from '../keyring.js';
-import { getCliSubdomains } from '../status.js';
-
-type MiddlewareArgs = ArgumentsCamelCase<Record<string, unknown>>;
-
-export async function subdomainMiddleware(argv: MiddlewareArgs): Promise<void> {
-  if (typeof argv.subdomain === 'string' && argv.subdomain.length > 0) return;
-  const fromConfig = getConfigValue('subdomain');
-  if (fromConfig) {
-    argv.subdomain = fromConfig;
-    return;
-  }
-  const accessToken = await getAccessToken();
-  if (!accessToken) return;
-  const subdomains = await getCliSubdomains(accessToken);
-  argv.subdomain = subdomains[0];
-}

package/src/middlewares/telemetryMiddleware.ts

@@ -1,55 +0,0 @@
-import { getConfigValue } from '../config.js';
-import { getVersions } from '../helpers.js';
-import { trackCommand } from '../telemetry/track.js';
-
-const SCRAPE_SUBCOMMANDS = new Set(['page', 'site', 'openapi']);
-const ANALYTICS_SUBCOMMANDS = new Set(['stats', 'search', 'feedback', 'conversation']);
-const CONFIG_SUBCOMMANDS = new Set(['set', 'get', 'clear']);
-const CONVERSATION_SUBCOMMANDS = new Set(['list', 'view', 'buckets']);
-const BUCKETS_SUBCOMMANDS = new Set(['list', 'view']);
-
-export function getSanitizedCommandForTelemetry(_: (string | number)[]): string {
-  const parts = _.filter((p): p is string => typeof p === 'string');
-  if (parts.length === 0) return '';
-  const first = parts[0]!;
-  const second = parts[1];
-  const third = parts[2];
-
-  if (first === 'scrape' && second !== undefined && SCRAPE_SUBCOMMANDS.has(second)) {
-    return `scrape ${second}`;
-  }
-
-  if (first === 'config' && second !== undefined && CONFIG_SUBCOMMANDS.has(second)) {
-    return `config ${second}`;
-  }
-
-  if (first === 'analytics' && second !== undefined && ANALYTICS_SUBCOMMANDS.has(second)) {
-    if (second === 'conversation' && third !== undefined) {
-      if (CONVERSATION_SUBCOMMANDS.has(third)) {
-        const fourth = parts[3];
-        if (third === 'buckets' && fourth !== undefined && BUCKETS_SUBCOMMANDS.has(fourth)) {
-          return `analytics conversation buckets ${fourth}`;
-        }
-        return `analytics conversation ${third}`;
-      }
-    }
-    return `analytics ${second}`;
-  }
-
-  return first;
-}
-
-export function createTelemetryMiddleware(): (argv: { _: (string | number)[] }) => Promise<void> {
-  let tracked = false;
-  return async function telemetryMiddleware(argv: { _: (string | number)[] }): Promise<void> {
-    const command = argv._[0];
-    if (typeof command === 'string') {
-      if (tracked) return;
-      tracked = true;
-      const sanitizedCommand = getSanitizedCommandForTelemetry(argv._);
-      const { cli: cliVersion } = getVersions();
-      const subdomain = getConfigValue('subdomain');
-      void trackCommand({ command: sanitizedCommand, cliVersion, subdomain });
-    }
-  };
-}

package/src/migrate.ts

@@ -1,76 +0,0 @@
-import { spawn } from 'node:child_process';
-import { readdirSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { windowsCompatibleSpawnOptions } from './helpers.js';
-
-type Section = 'topics' | 'sources';
-
-const root = fileURLToPath(new URL('../migrate', import.meta.url));
-
-const read = (...segments: string[]) => readFileSync(path.join(root, ...segments), 'utf8');
-
-export const listMigrationDocs = (section: Section) =>
-  readdirSync(path.join(root, section))
-    .filter((file) => file.endsWith('.md'))
-    .map((file) => file.slice(0, -3))
-    .sort();
-
-const overview = () =>
-  [
-    read('index.md').trimEnd(),
-    `Topics: ${listMigrationDocs('topics').join(', ')}. Run \`mint migrate --topic <name>\`.`,
-    `Sources: ${listMigrationDocs('sources').join(', ')}. Run \`mint migrate --from <name>\`.`,
-  ].join('\n\n');
-
-export const migrationInstructions = ({ from, topic }: { from?: string; topic?: string }) => {
-  if (topic) return read('topics', `${topic}.md`);
-  if (from) return `${overview()}\n\n${read('sources', `${from}.md`)}`;
-  return `${overview()}\n`;
-};
-
-const prompt = (from?: string) =>
-  `Migrate a documentation site to Mintlify in the current directory. Run \`mint migrate${from ? ` --from ${from}` : ''}\` and follow the instructions it prints.`;
-
-export const agents = {
-  claude: {
-    bin: 'claude',
-    args: (prompt: string) => [prompt],
-    install: 'npm install -g @anthropic-ai/claude-code',
-  },
-  codex: {
-    bin: 'codex',
-    args: (prompt: string) => [prompt],
-    install: 'npm install -g @openai/codex',
-  },
-  cursor: {
-    bin: 'cursor-agent',
-    args: (prompt: string) => [prompt],
-    install: 'curl https://cursor.com/install -fsS | bash',
-  },
-  gemini: {
-    bin: 'gemini',
-    args: (prompt: string) => ['-i', prompt],
-    install: 'npm install -g @google/gemini-cli',
-  },
-};
-
-export type AgentName = keyof typeof agents;
-
-export const agentArgs = (name: AgentName, from?: string) => agents[name].args(prompt(from));
-
-export const migrateWithAgent = (name: AgentName, from?: string): Promise<number> =>
-  new Promise((resolve, reject) => {
-    const { bin, install } = agents[name];
-    const args = agentArgs(name, from).map((arg) =>
-      windowsCompatibleSpawnOptions.shell ? `"${arg}"` : arg
-    );
-    const child = spawn(bin, args, { stdio: 'inherit', ...windowsCompatibleSpawnOptions });
-    child.on('error', (error: NodeJS.ErrnoException) =>
-      reject(
-        error.code === 'ENOENT' ? new Error(`${bin} not found. Install it with: ${install}`) : error
-      )
-    );
-    child.on('close', (code) => resolve(code ?? 1));
-  });

package/src/og.tsx

@@ -1,185 +0,0 @@
-import { parseFrontmatter, slugToTitle } from '@mintlify/common';
-import { renderOgCardPng } from '@mintlify/og';
-import {
-  applyCardThemeOverride,
-  applyThumbnailOverride,
-  buildOgCardInput,
-  checkOgCard,
-  createLocalAssetLoaders,
-  deriveOgThemeParams,
-  getOgPageParams,
-  MAX_OG_ASSET_BYTES,
-  toOgFontAsset,
-  toOgImageAsset,
-  type OgAssetLoaders,
-} from '@mintlify/og/config';
-import { getConfigObj } from '@mintlify/prebuild';
-import { addLog, ErrorLog, SuccessLog, WarningLog } from '@mintlify/previewing';
-import { validateDocsConfig, type ThumbnailOverride } from '@mintlify/validation';
-import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import open from 'open';
-
-import { CMD_EXEC_PATH } from './helpers.js';
-
-export type OgCommandOptions = Pick<ThumbnailOverride, 'preset' | 'surface' | 'appearance'> & {
-  page?: string;
-  output?: string;
-  open: boolean;
-};
-
-const REMOTE_TIMEOUT_MS = 5_000;
-const PAGE_EXTENSIONS = ['.mdx', '.md'];
-const MAX_REPORTED_ISSUES = 5;
-
-const readLimited = async (response: Response): Promise<Uint8Array | null> => {
-  const declared = Number(response.headers.get('content-length'));
-  if (declared > MAX_OG_ASSET_BYTES || !response.body) return null;
-
-  const reader = response.body.getReader();
-  const chunks: Uint8Array[] = [];
-  let size = 0;
-  for (let result = await reader.read(); !result.done; result = await reader.read()) {
-    size += result.value.byteLength;
-    if (size > MAX_OG_ASSET_BYTES) {
-      await reader.cancel();
-      return null;
-    }
-    chunks.push(result.value);
-  }
-
-  const bytes = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return bytes;
-};
-
-const fetchAsset = async (src: string) => {
-  try {
-    const response = await fetch(src, { signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS) });
-    if (!response.ok) return null;
-    const bytes = await readLimited(response);
-    return bytes && { bytes, contentType: response.headers.get('content-type') ?? undefined };
-  } catch {
-    return null;
-  }
-};
-
-const remoteLoaders: OgAssetLoaders = {
-  image: async (src) => {
-    const asset = await fetchAsset(src);
-    return asset && toOgImageAsset(asset.bytes, asset.contentType);
-  },
-  font: async (src) => {
-    const asset = await fetchAsset(src);
-    return asset && toOgFontAsset(asset.bytes);
-  },
-};
-
-const normalizePagePath = (page: string | undefined) =>
-  path.posix
-    .normalize(`/${(page ?? '').replace(/\\/g, '/')}`)
-    .replace(/^\/+|\/+$/g, '')
-    .replace(/\.mdx?$/, '') || 'index';
-
-const pageHref = (pagePath: string) => pagePath.replace(/(^|\/)index$/, '');
-
-const pageCandidates = (pagePath: string) =>
-  [pagePath, `${pagePath}/index`].flatMap((base) =>
-    PAGE_EXTENSIONS.map((extension) => `${base}${extension}`)
-  );
-
-const readPage = async (pagePath: string) => {
-  const root = path.resolve(CMD_EXEC_PATH);
-  for (const candidate of pageCandidates(pagePath)) {
-    const filePath = path.resolve(root, candidate);
-    if (!filePath.startsWith(`${root}${path.sep}`)) return null;
-    try {
-      return await readFile(filePath, 'utf-8');
-    } catch {
-      continue;
-    }
-  }
-  return null;
-};
-
-const stringAttribute = (attributes: Record<string, unknown>, key: string) => {
-  const value = attributes[key];
-  return typeof value === 'string' && value ? value : undefined;
-};
-
-const defaultOutputPath = async (pagePath: string) =>
-  path.join(
-    await mkdtemp(path.join(os.tmpdir(), 'mintlify-og-')),
-    `${pagePath.replace(/\//g, '-')}.png`
-  );
-
-export async function ogCommand(options: OgCommandOptions): Promise<0 | 1> {
-  const rawConfig = await getConfigObj(CMD_EXEC_PATH, 'docs');
-  if (!rawConfig) {
-    addLog(<ErrorLog message="No docs.json found. Run mint og from your docs directory." />);
-    return 1;
-  }
-
-  const validation = validateDocsConfig(rawConfig);
-  if (!validation.success) {
-    const issues = validation.error.issues
-      .slice(0, MAX_REPORTED_ISSUES)
-      .map((issue) => `${issue.path.join('.') || 'docs.json'}: ${issue.message}`);
-    addLog(<ErrorLog message={`docs.json is invalid:\n${issues.join('\n')}`} />);
-    return 1;
-  }
-  const docsConfig = validation.data;
-
-  const pagePath = normalizePagePath(options.page);
-  const contents = await readPage(pagePath);
-  if (contents === null) {
-    addLog(
-      <ErrorLog message={`Couldn't find a page at ${pageCandidates(pagePath).join(', ')}.`} />
-    );
-    return 1;
-  }
-
-  const { attributes } = parseFrontmatter<Record<string, unknown>>(contents);
-  const pageParams = getOgPageParams(
-    {
-      path: pagePath,
-      title:
-        stringAttribute(attributes, 'title') ??
-        stringAttribute(attributes, 'sidebarTitle') ??
-        slugToTitle(pageHref(pagePath)),
-      description: stringAttribute(attributes, 'description'),
-      thumbnail: attributes.thumbnail,
-    },
-    docsConfig
-  );
-  const themeParams = applyThumbnailOverride(
-    applyCardThemeOverride(deriveOgThemeParams(docsConfig), pageParams.thumbnail),
-    options
-  );
-
-  const input = await buildOgCardInput(
-    pageParams,
-    themeParams,
-    createLocalAssetLoaders(CMD_EXEC_PATH, remoteLoaders)
-  );
-  const png = await renderOgCardPng(input);
-
-  const outputPath = options.output
-    ? path.resolve(options.output)
-    : await defaultOutputPath(pagePath);
-  await mkdir(path.dirname(outputPath), { recursive: true });
-  await writeFile(outputPath, new Uint8Array(png));
-
-  for (const warning of checkOgCard(input, themeParams)) {
-    addLog(<WarningLog message={warning} />);
-  }
-  addLog(<SuccessLog message={`Wrote ${outputPath}`} />);
-
-  if (options.open && !process.env.CI) await open(outputPath);
-  return 0;
-}

package/src/openApiCheck.tsx

@@ -1,125 +0,0 @@
-import {
-  applyOverlays,
-  createOverlayRegistry,
-  getOpenApiDocumentFromUrl,
-  isAllowedLocalSchemaUrl,
-  resolveOverlaysForSpec,
-  validate,
-  type OverlayRegistry,
-} from '@mintlify/common';
-import { discoverOverlayFiles, getMintIgnore, resolveFileRefs } from '@mintlify/prebuild';
-import { addLog, ErrorLog, SuccessLog, WarningLog } from '@mintlify/previewing';
-import {
-  collectOpenApiOverlayConfig,
-  extractOpenApiEntries,
-  type DocsConfig,
-} from '@mintlify/validation';
-import { promises as fs } from 'fs';
-import path from 'path';
-
-import { CMD_EXEC_PATH, readLocalOpenApiFile } from './helpers.js';
-
-export const getOpenApiFilenamesFromDocsConfig = (config: Pick<DocsConfig, 'api'>): string[] => {
-  return extractOpenApiEntries(config.api?.openapi).map((entry) => entry.source);
-};
-
-/**
- * Builds the overlay registry so checks validate specs with overlays applied.
- * Throws when docs.json configures conflicting overlay lists, matching the build.
- */
-export const buildOverlayRegistryForCheck = async (
-  localSchema?: boolean
-): Promise<OverlayRegistry | undefined> => {
-  // Discovery failures propagate and fail the check: silently skipping overlays would
-  // validate a different document than the one the build produces.
-  const mintIgnore = await getMintIgnore(CMD_EXEC_PATH);
-  const discovered = await discoverOverlayFiles(CMD_EXEC_PATH, mintIgnore);
-
-  let rawConfig: unknown;
-  try {
-    rawConfig = JSON.parse(await fs.readFile(path.join(CMD_EXEC_PATH, 'docs.json'), 'utf-8'));
-  } catch {
-    rawConfig = undefined;
-  }
-  if (rawConfig !== undefined) {
-    try {
-      rawConfig = (await resolveFileRefs(rawConfig, CMD_EXEC_PATH)).resolved;
-    } catch {
-      // Broken $refs are reported by regular config validation; collect from the root file.
-    }
-  }
-  const explicit = rawConfig == undefined ? undefined : collectOpenApiOverlayConfig(rawConfig);
-
-  if (explicit == undefined && discovered.length === 0) return undefined;
-
-  return createOverlayRegistry({
-    explicit,
-    discovered,
-    localSchema,
-    loadLocalDocument: (normalizedPath) => readLocalOpenApiFile(normalizedPath),
-  });
-};
-
-export type OpenApiCheckMessage = { level: 'success' | 'warning' | 'error'; message: string };
-
-const logOpenApiMessage = ({ level, message }: OpenApiCheckMessage) => {
-  addLog(
-    level === 'success' ? (
-      <SuccessLog message={message} />
-    ) : level === 'warning' ? (
-      <WarningLog message={message} />
-    ) : (
-      <ErrorLog message={message} />
-    )
-  );
-};
-
-export const checkOpenApiFile = async (
-  filename: string,
-  localSchema: boolean,
-  overlayRegistry?: OverlayRegistry,
-  report: (message: OpenApiCheckMessage) => void = logOpenApiMessage
-): Promise<boolean> => {
-  try {
-    const overlays = overlayRegistry ? await resolveOverlaysForSpec(overlayRegistry, filename) : [];
-
-    if (isAllowedLocalSchemaUrl(filename, localSchema)) {
-      await getOpenApiDocumentFromUrl(filename, { overlays });
-      report({ level: 'success', message: 'OpenAPI definition is valid.' });
-      return true;
-    }
-
-    if (filename.startsWith('http://') && !localSchema) {
-      report({
-        level: 'warning',
-        message: 'include the --local-schema flag to check locally hosted OpenAPI files',
-      });
-      report({ level: 'warning', message: 'only https protocol is supported in production' });
-      return true;
-    }
-
-    const document = await readLocalOpenApiFile(filename);
-    if (!document) {
-      throw new Error(
-        'failed to parse OpenAPI spec: could not parse file correctly, please check for any syntax errors.'
-      );
-    }
-    const overlaid: unknown = overlays.length > 0 ? applyOverlays(document, overlays) : document;
-    if (overlaid == undefined || typeof overlaid !== 'object') {
-      throw new Error('applying overlays produced an invalid OpenAPI document.');
-    }
-    await validate(overlaid);
-    report({ level: 'success', message: 'OpenAPI definition is valid.' });
-    return true;
-  } catch (err) {
-    if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
-      report({
-        level: 'error',
-        message: `file not found, please check the path provided: ${filename}`,
-      });
-    } else {
-      report({ level: 'error', message: err instanceof Error ? err.message : 'unknown error' });
-    }
-    return false;
-  }
-};