@mintlify/cli 4.0.1813 → 4.1.1

package/__test__/foreignSyntax.test.ts

@@ -1,73 +0,0 @@
-import { foreignSyntax } from '../src/validate/rules/content/foreignSyntax.js';
-
-const check = (content: string) =>
-  foreignSyntax.check({
-    file: 'page.mdx',
-    content,
-    baseDir: '/',
-    frontmatter: {},
-    tree: { type: 'root', children: [] },
-  });
-
-const messages = (content: string) => check(content).map(({ message }) => message);
-
-describe('foreign-syntax', () => {
-  it.each([
-    ['GitBook hint', '{% hint style="warning" %}\nCareful\n{% endhint %}\n', '<Warning>'],
-    ['Liquid tag', '{% include note.html %}\n', 'snippet import'],
-    ['Hugo shortcode', '{{< figure src="a.png" >}}\n', 'Hugo shortcode'],
-    ['Liquid variable', 'Version {{ site.version }}\n', 'Liquid variable'],
-    ['Liquid filter', '[Home]({{ "/" | relative_url }})\n', 'Liquid variable'],
-    ['Docusaurus admonition', ':::tip\nUse it\n:::\n', '<Tip>'],
-    ['VitePress admonition with title', '::: warning Heads up\nx\n:::\n', '<Warning>'],
-    ['MDC block', '::note\nx\n::\n', 'MDC'],
-    ['MkDocs admonition', '!!! note "Title"\n    Body\n', '<Note>'],
-    ['MkDocs collapsible', '??? info\n    Body\n', '<Accordion>'],
-    ['MkDocs tab', '=== "Python"\n    code\n', '<Tabs>'],
-    ['MkDocs snippet in a fence', '```py\n--8<-- "example.py"\n```\n', 'snippet include'],
-    ['Kramdown IAL', 'Text\n{: .note }\n', 'Kramdown'],
-    ['wiki link', 'See [[Getting Started]].\n', 'wiki link'],
-    ['wiki link with label', 'See [[setup|Install]].\n', 'wiki link'],
-    ['ReadMe doc link', 'See [setup](doc:setup).\n', 'such as /setup'],
-    ['ReadMe ref link in href', '<a href="ref:create-user">x</a>\n', 'such as /create-user'],
-    [
-      'Docusaurus @site import',
-      "import Img from '@site/static/img/a.png';\n\n<img src={Img} />\n",
-      '@site',
-    ],
-  ])('flags %s', (_name, content, expected) => {
-    const found = messages(content);
-    expect(found).toHaveLength(1);
-    expect(found[0]).toContain(expected);
-  });
-
-  it('flags each opening GitBook tag once, not its closing tag', () => {
-    expect(messages('{% tabs %}\n{% tab title="A" %}\nx\n{% endtab %}\n{% endtabs %}\n')).toEqual([
-      expect.stringContaining('use <Tabs>'),
-      expect.stringContaining('use <Tab title="…">'),
-    ]);
-  });
-
-  it.each([
-    ['fenced code', '```liquid\n{% hint style="info" %}\n{{ site.title }}\n:::note\n```\n'],
-    ['inline code', 'Write `{% hint %}`, `:::note` and `[[Page]]` like this.\n'],
-    ['frontmatter', '---\ntitle: "{% hint %}"\ndescription: "[[Page]]"\n---\n\nBody\n'],
-    ['MDX expressions', 'Total: {a | b} and {{ x: 1 }.x} and {[[1, 2]].length} and {{page}}\n'],
-    ['closing tags and bare fences', ':::\n\n::\n'],
-    ['Markdown link after a bracket', '[[1]](#note-1) and [a][ref]\n'],
-    ['ordinary prose', 'Use doc: the guide. Wow!!! Equal === sign.\n'],
-    ['custom heading ids', '## Install {#install}\n'],
-  ])('ignores %s', (_name, content) => {
-    expect(messages(content)).toEqual([]);
-  });
-
-  it('reports positions in the original file', () => {
-    expect(check('---\ntitle: A\n---\n\nText\n  :::note\nx\n:::\n')).toEqual([
-      expect.objectContaining({ line: 6, column: 3 }),
-    ]);
-  });
-
-  it('never offers edits', () => {
-    expect(check('{% hint %}\n').every(({ edit }) => edit === undefined)).toBe(true);
-  });
-});

package/__test__/format.test.ts

@@ -1,72 +0,0 @@
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { formatHandler } from '../src/format.js';
-import { terminate } from '../src/helpers.js';
-
-const fixture = vi.hoisted(() => ({ directory: '' }));
-
-vi.mock('../src/helpers.js', () => ({
-  get CMD_EXEC_PATH() {
-    return fixture.directory;
-  },
-  terminate: vi.fn(),
-}));
-
-vi.mock('@mintlify/prebuild', () => ({ getMintIgnore: vi.fn(async () => []) }));
-vi.mock('@mintlify/previewing', () => ({
-  addLog: vi.fn(),
-  ErrorLog: () => null,
-  SuccessLog: () => null,
-}));
-
-beforeEach(async () => {
-  vi.clearAllMocks();
-  fixture.directory = await fs.mkdtemp(path.join(os.tmpdir(), 'mint-format-math-'));
-});
-
-afterEach(async () => {
-  vi.restoreAllMocks();
-  await fs.rm(fixture.directory, { recursive: true, force: true });
-});
-
-describe('formatHandler math and currency', () => {
-  it.each([
-    ['single-dollar math', 'The formula is $x$ in text', 'The formula is $$x$$ in text'],
-    [
-      'paired currency dollars (escaped, not converted to math)',
-      'Savings are $1 today ($5 tomorrow).',
-      'Savings are \\$1 today (\\$5 tomorrow).',
-    ],
-    ['literal currency', 'Savings are $1 today.', 'Savings are \\$1 today.'],
-    [
-      'escaped currency',
-      'Savings are \\$1 today (\\$5 tomorrow).',
-      'Savings are \\$1 today (\\$5 tomorrow).',
-    ],
-    ['double-dollar math', 'The formula is $$x$$ in text', 'The formula is $$x$$ in text'],
-    ['double-dollar math followed by a digit', 'The value is $$2^3$$8.', 'The value is $$2^3$$8.'],
-    [
-      'paired currency dollars on a page with an HTML comment',
-      '<!-- note -->\n\nSavings are $1 today ($5 tomorrow).',
-      '{/*  note  */}\n\nSavings are \\$1 today (\\$5 tomorrow).',
-    ],
-  ])('preserves %s and produces stable output', async (_label, source, expected) => {
-    const file = path.join(fixture.directory, 'page.mdx');
-    await fs.writeFile(file, source);
-    const writeFile = vi.spyOn(fs, 'writeFile');
-
-    await formatHandler();
-
-    expect(terminate).toHaveBeenLastCalledWith(0);
-    expect(await fs.readFile(file, 'utf8')).toBe(`${expected}\n`);
-    writeFile.mockClear();
-
-    await formatHandler();
-
-    expect(terminate).toHaveBeenLastCalledWith(0);
-    expect(writeFile).not.toHaveBeenCalled();
-  });
-});

package/__test__/helpers.test.ts

@@ -1,52 +0,0 @@
-import { LOCAL_LINKED_CLI_VERSION } from '@mintlify/previewing';
-
-import { assertValidPackageName, getCliVersion } from '../src/helpers.js';
-
-describe('getCliVersion', () => {
-  const originalTestMode = process.env.CLI_TEST_MODE;
-
-  afterEach(() => {
-    if (originalTestMode === undefined) {
-      delete process.env.CLI_TEST_MODE;
-    } else {
-      process.env.CLI_TEST_MODE = originalTestMode;
-    }
-  });
-
-  it('returns a test marker when CLI_TEST_MODE is enabled', () => {
-    process.env.CLI_TEST_MODE = 'true';
-    expect(getCliVersion('mint')).toBe('test-cli');
-  });
-
-  it(
-    'returns LOCAL_LINKED_CLI_VERSION when running from the monorepo source ' +
-      '(not inside node_modules)',
-    () => {
-      delete process.env.CLI_TEST_MODE;
-      expect(getCliVersion('mint')).toBe(LOCAL_LINKED_CLI_VERSION);
-    }
-  );
-});
-
-describe('assertValidPackageName', () => {
-  it.each(['mint', 'mintlify', '@mintlify/cli', 'some-pkg.name~2'])(
-    'accepts valid npm package name %s',
-    (name) => {
-      expect(() => assertValidPackageName(name)).not.toThrow();
-    }
-  );
-
-  it.each([
-    'mint; rm -rf /',
-    'mint && calc.exe',
-    'mint | whoami',
-    'mint`whoami`',
-    'mint$(whoami)',
-    'mint @latest',
-    '../mint',
-    'Mint',
-    '',
-  ])('rejects %s', (name) => {
-    expect(() => assertValidPackageName(name)).toThrow('Invalid package name');
-  });
-});

package/__test__/init.test.ts

@@ -1,119 +0,0 @@
-import { input, select } from '@inquirer/prompts';
-
-import { isAI } from '../src/helpers.js';
-import { init } from '../src/init.js';
-
-vi.mock('@inquirer/prompts', () => ({
-  select: vi.fn(),
-  input: vi.fn(),
-}));
-
-vi.mock('../src/helpers.js', () => ({
-  isAI: vi.fn().mockReturnValue(false),
-}));
-
-vi.mock('@mintlify/previewing', () => ({
-  addLogs: vi.fn(),
-  addLog: vi.fn(),
-  SpinnerLog: vi.fn(),
-  removeLastLog: vi.fn(),
-}));
-
-vi.mock('@mintlify/validation', async () => {
-  const original =
-    await vi.importActual<typeof import('@mintlify/validation')>('@mintlify/validation');
-  return {
-    ...original,
-    docsConfigSchema: {
-      options: [{ shape: { theme: { _def: { value: 'quill' } } } }],
-    },
-  };
-});
-
-vi.mock('fs-extra', () => ({
-  default: {
-    readdir: vi.fn().mockResolvedValue([]),
-    ensureDir: vi.fn().mockResolvedValue(undefined),
-    writeFile: vi.fn().mockResolvedValue(undefined),
-    copy: vi.fn().mockResolvedValue(undefined),
-    remove: vi.fn().mockResolvedValue(undefined),
-    readJson: vi.fn().mockResolvedValue({ theme: 'quill', name: 'Test' }),
-    writeJson: vi.fn().mockResolvedValue(undefined),
-    pathExists: vi.fn().mockResolvedValue(true),
-  },
-}));
-
-vi.mock('adm-zip', () => ({
-  default: vi.fn().mockImplementation(() => ({
-    extractAllTo: vi.fn(),
-  })),
-}));
-
-global.fetch = vi.fn().mockResolvedValue({
-  ok: true,
-  arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-  json: () => Promise.resolve([]),
-});
-
-describe('init', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    (global.fetch as ReturnType<typeof vi.fn>).mockResolvedValue({
-      ok: true,
-      arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-      json: () => Promise.resolve([]),
-    });
-  });
-
-  describe('path traversal prevention', () => {
-    it('rejects path traversal with ../', async () => {
-      await expect(init('../outside', false, 'quill', 'Test')).rejects.toThrow(
-        'Access denied: path: ../outside is outside the current directory'
-      );
-    });
-
-    it('rejects deep path traversal', async () => {
-      await expect(init('../../../etc', false, 'quill', 'Test')).rejects.toThrow(
-        'Access denied: path: ../../../etc is outside the current directory'
-      );
-    });
-
-    it('rejects absolute paths outside cwd', async () => {
-      await expect(init('/etc/test', false, 'quill', 'Test')).rejects.toThrow(
-        'Access denied: path: /etc/test is outside the current directory'
-      );
-    });
-
-    it('allows current directory (.)', async () => {
-      await expect(init('.', false, 'quill', 'Test')).resolves.not.toThrow();
-    });
-
-    it('allows subdirectory paths', async () => {
-      await expect(init('docs', false, 'quill', 'Test')).resolves.not.toThrow();
-    });
-
-    it('allows nested subdirectory paths', async () => {
-      await expect(init('docs/api', false, 'quill', 'Test')).resolves.not.toThrow();
-    });
-  });
-
-  describe('AI agent guard for template without name', () => {
-    it('does not call interactive prompts when AI uses --template without --name', async () => {
-      vi.mocked(isAI).mockReturnValue(true);
-
-      await init('.', false, undefined, undefined, 'some-template');
-
-      expect(input).not.toHaveBeenCalled();
-      expect(select).not.toHaveBeenCalled();
-    });
-
-    it('does not call interactive prompts when AI omits both --template and --theme', async () => {
-      vi.mocked(isAI).mockReturnValue(true);
-
-      await init('.', false, undefined, 'MyProject');
-
-      expect(input).not.toHaveBeenCalled();
-      expect(select).not.toHaveBeenCalled();
-    });
-  });
-});

package/__test__/instructions.test.ts

@@ -1,53 +0,0 @@
-import {
-  fetchInstructions,
-  instructionsUrl,
-  INSTRUCTIONS_URL,
-  TOPICS,
-} from '../src/instructions.js';
-
-const docsMarkdown = [
-  '> ## Documentation Index',
-  '> Fetch the complete documentation index at: https://www.mintlify.com/docs/llms.txt',
-  '',
-  '> ## Agent Instructions',
-  '> Follow the quickstart.',
-  '',
-  '# Custom domain',
-  '',
-  '> Set up a custom domain.',
-  '',
-  'Body',
-].join('\n');
-
-describe('instructions', () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('maps topics to docs page paths', () => {
-    expect(instructionsUrl(['publish'])).toBe(`${INSTRUCTIONS_URL}/publish.md`);
-    expect(instructionsUrl(['publish', 'domain'])).toBe(`${INSTRUCTIONS_URL}/publish/domain.md`);
-  });
-
-  it('lists only topics that map to distinct pages', () => {
-    const urls = TOPICS.map(({ name }) => instructionsUrl(name.split(' ')));
-    expect(new Set(urls).size).toBe(TOPICS.length);
-    expect(TOPICS.every(({ name }) => name.split(' ').length <= 2)).toBe(true);
-  });
-
-  it('returns the page without the docs site preamble', async () => {
-    const fetchMock = vi.fn().mockResolvedValue(new Response(docsMarkdown));
-    vi.stubGlobal('fetch', fetchMock);
-
-    const markdown = await fetchInstructions(['publish', 'domain']);
-
-    expect(fetchMock).toHaveBeenCalledWith(`${INSTRUCTIONS_URL}/publish/domain.md`);
-    expect(markdown).toBe('# Custom domain\n\n> Set up a custom domain.\n\nBody');
-  });
-
-  it('rejects unknown topics', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('', { status: 404 })));
-
-    await expect(fetchInstructions(['nope'])).rejects.toThrow();
-  });
-});

package/__test__/keyring.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-const mockKeytar = {
-  setPassword: vi.fn().mockResolvedValue(undefined),
-  getPassword: vi.fn().mockResolvedValue('test-token'),
-  deletePassword: vi.fn().mockResolvedValue(true),
-};
-
-vi.mock('keytar', () => ({
-  default: mockKeytar,
-  setPassword: mockKeytar.setPassword,
-  getPassword: mockKeytar.getPassword,
-  deletePassword: mockKeytar.deletePassword,
-}));
-
-describe('keyring', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.resetModules();
-  });
-
-  it('stores access token, refresh token, and user email via keytar', async () => {
-    const { storeCredentials } = await import('../src/keyring.js');
-    await storeCredentials('access', 'refresh', 'dev@mintlify.com');
-    expect(mockKeytar.setPassword).toHaveBeenCalledWith('mintlify', 'access_token', 'access');
-    expect(mockKeytar.setPassword).toHaveBeenCalledWith('mintlify', 'refresh_token', 'refresh');
-    expect(mockKeytar.setPassword).toHaveBeenCalledWith(
-      'mintlify',
-      'user_email',
-      'dev@mintlify.com'
-    );
-  });
-
-  it('retrieves the access token via keytar', async () => {
-    const { getAccessToken } = await import('../src/keyring.js');
-    const token = await getAccessToken();
-    expect(token).toBe('test-token');
-    expect(mockKeytar.getPassword).toHaveBeenCalledWith('mintlify', 'access_token');
-  });
-
-  it('retrieves the refresh token via keytar', async () => {
-    const { getRefreshToken } = await import('../src/keyring.js');
-    const token = await getRefreshToken();
-    expect(token).toBe('test-token');
-    expect(mockKeytar.getPassword).toHaveBeenCalledWith('mintlify', 'refresh_token');
-  });
-
-  it('retrieves the user email via keytar', async () => {
-    const { getUserEmail } = await import('../src/keyring.js');
-    const email = await getUserEmail();
-    expect(email).toBe('test-token');
-    expect(mockKeytar.getPassword).toHaveBeenCalledWith('mintlify', 'user_email');
-  });
-
-  it('stores the user email via keytar', async () => {
-    const { storeUserEmail } = await import('../src/keyring.js');
-    await storeUserEmail('dev@mintlify.com');
-    expect(mockKeytar.setPassword).toHaveBeenCalledWith(
-      'mintlify',
-      'user_email',
-      'dev@mintlify.com'
-    );
-  });
-
-  it('deletes tokens and user email via keytar', async () => {
-    const { clearCredentials } = await import('../src/keyring.js');
-    await clearCredentials();
-    expect(mockKeytar.deletePassword).toHaveBeenCalledWith('mintlify', 'access_token');
-    expect(mockKeytar.deletePassword).toHaveBeenCalledWith('mintlify', 'refresh_token');
-    expect(mockKeytar.deletePassword).toHaveBeenCalledWith('mintlify', 'user_email');
-  });
-
-  it('throws a helpful error when keytar is not installed', async () => {
-    vi.doMock('keytar', () => {
-      throw new Error('Cannot find module');
-    });
-    const { storeCredentials } = await import('../src/keyring.js');
-    await expect(storeCredentials('a', 'b')).rejects.toThrow(
-      'keytar is required for credential storage but is not installed'
-    );
-  });
-});

package/__test__/mdxAccessibility.test.ts

@@ -1,81 +0,0 @@
-import fs from 'fs';
-
-import { checkMdxAccessibility } from '../src/mdxAccessibility.js';
-
-vi.mock('@mintlify/prebuild', async (importOriginal) => {
-  const mod = await importOriginal<typeof import('@mintlify/prebuild')>();
-  return {
-    ...mod,
-    getMintIgnore: vi.fn(async () => []),
-    categorizeFilePaths: vi.fn(async () => ({ contentFilenames: ['test.mdx'] })),
-  };
-});
-
-vi.mock('fs');
-
-const mockReadFileSync = vi.mocked(fs.readFileSync);
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe('checkMdxAccessibility', () => {
-  it('detects missing alt on markdown image', async () => {
-    mockReadFileSync.mockReturnValueOnce('![](image.png)' as unknown as Buffer);
-    const result = await checkMdxAccessibility('/docs');
-    expect(result.missingAltAttributes).toHaveLength(1);
-    expect(result.missingAltAttributes[0]?.element).toBe('img');
-  });
-
-  it('detects missing alt on JSX img', async () => {
-    mockReadFileSync.mockReturnValueOnce('<img src="image.png" />' as unknown as Buffer);
-    const result = await checkMdxAccessibility('/docs');
-    expect(result.missingAltAttributes).toHaveLength(1);
-    expect(result.missingAltAttributes[0]?.element).toBe('img');
-  });
-
-  it('detects missing alt on JSX video', async () => {
-    mockReadFileSync.mockReturnValueOnce('<video src="clip.mp4" />' as unknown as Buffer);
-    const result = await checkMdxAccessibility('/docs');
-    expect(result.missingAltAttributes).toHaveLength(1);
-    expect(result.missingAltAttributes[0]?.element).toBe('video');
-  });
-
-  it('detects empty anchor', async () => {
-    mockReadFileSync.mockReturnValueOnce('<a href="/page"></a>' as unknown as Buffer);
-    const result = await checkMdxAccessibility('/docs');
-    expect(result.missingAltAttributes).toHaveLength(1);
-    expect(result.missingAltAttributes[0]?.element).toBe('a');
-  });
-
-  it('passes when alt text is present', async () => {
-    mockReadFileSync.mockReturnValueOnce('![A cat](cat.png)' as unknown as Buffer);
-    const result = await checkMdxAccessibility('/docs');
-    expect(result.missingAltAttributes).toHaveLength(0);
-  });
-
-  it('does not skip files containing {#id} heading syntax', async () => {
-    const content = '## Heading {#custom-id}\n\n<img src="image.png" />';
-    mockReadFileSync.mockReturnValueOnce(content as unknown as Buffer);
-    const result = await checkMdxAccessibility('/docs');
-    expect(result.missingAltAttributes).toHaveLength(1);
-    expect(result.missingAltAttributes[0]?.element).toBe('img');
-  });
-
-  it('reports accurate line numbers when {#id} heading precedes the issue', async () => {
-    const content = '## Heading {#custom-id}\n\n<img src="image.png" />';
-    mockReadFileSync.mockReturnValueOnce(content as unknown as Buffer);
-    const result = await checkMdxAccessibility('/docs');
-    expect(result.missingAltAttributes[0]?.line).toBe(2);
-  });
-
-  it('returns correct totals', async () => {
-    mockReadFileSync.mockReturnValueOnce(
-      '<img src="a.png" />\n<img src="b.png" />' as unknown as Buffer
-    );
-    const result = await checkMdxAccessibility('/docs');
-    expect(result.totalFiles).toBe(1);
-    expect(result.filesWithIssues).toBe(1);
-    expect(result.missingAltAttributes).toHaveLength(2);
-  });
-});