::-webkit-scrollbar {
  width: 6px;
}

::-webkit-scrollbar-track {
  background: white;
}

::-webkit-scrollbar-thumb {
  background-color: #eeee;
  border-radius: 10px;
  border: none;
}

html {
  scrollbar-width: thin;
  scrollbar-color: #eeee white;
  scrollbar-gutter: stable;
}

html.dark {
  scrollbar-width: thin;
  scrollbar-color: #222 #222;
  scrollbar-gutter: stable;
}

html.dark ::-webkit-scrollbar-track {
  background: #222;
}

html.dark ::-webkit-scrollbar-thumb {
  background-color: #222;
}

html.dark ::-webkit-scrollbar-thumb:hover {
  background-color: #333;
}

a:has(> code) {
  border-bottom: none !important;
}

a > code {
  cursor: pointer;
  border-bottom: #0c0c15 1px solid !important;
}

a > code:hover {
  border-bottom: #0c0c15 2px solid !important;
}

#content-area > div.leading-6.mt-14 > footer > div.sm\:flex > a {
  display: none;
}

@font-face {
  font-family: "GT Standard Mono";
  src: url("/fonts/GT-Standard-Mono-VF-Beta-V1.ttf") format("truetype");
  font-weight: 400 450 700; /* Normal to Bold */
  font-style: normal;
}

@font-face {
  font-family: "GT Standard";
  src: url("/fonts/GT-Standard-VF-Beta-V4.ttf") format("truetype");
  font-weight: 300 400 450 500 700 900; /* Normal to Bold */
  font-style: normal;
}

.gt-standard {
  font-family: "GT Standard", sans-serif;
}

.gt-standard-mono {
  font-family: "GT Standard Mono", monospace;
}

* {
  font-family: "GT Standard", sans-serif;
}

/* h1,
h2,
h3,
h4,
h5,
h6, */
.eyebrow,
code * {
  font-family: "GT Standard Mono", monospace;
}

#header h1 {
  font-size: 2.25rem;
}

/* #content-container h2 {
  font-size: 2rem;
}

#content-container h3 {
  font-size: 1.75rem;
}

#content-container h4 {
  font-size: 1.25rem;
} */

#sidebar #navigation-items > li:nth-child(1) {
  display: none;
}

.full-width-table table {
  display: table;
}

.full-width-table table th {
  text-align: left;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

.full-width-table table th:nth-child(3),
.full-width-table table th:nth-child(4) {
  text-align: center;
}


:not(.dark) .prose :where(a):not(:where([class~=not-prose],[class~=not-prose] *)):not(h1, h1 *, h2, h2 *, h3, h3 *, h4, h4 *, h5, h5 *, h6, h6 *) {
  border-bottom: #666666 1px solid;
}


img {
  border-radius: 0.5rem;
}

.max-pill {
  background-color: white;
  color: #0c0c15;
  padding: 1px 4px;
  border-radius: 8px;
  font-size: 0.6rem;
  font-weight: 500;
  display: inline-block;
  margin-left: 2px;
  margin-right: 4px;
  line-height: 1.2;
  border: 1px solid #0c0c15;
}

.dark .max-pill {
  background-color: #0c0c15;
  color: white;
  border-color: white;
}

.footnotes-container {
  display: grid;
  grid-template-columns: 1fr 1fr;
  gap: 1rem;
  margin-top: -14px;
  padding-bottom: 1rem;
  border-bottom: 1px solid rgb(var(--gray-800)/.5);
  line-height: 1.6;
}

.footnotes-container sup {
  margin-right: 0.35em;
}

.dark .footnotes-container {
  border-bottom-color: rgb(var(--gray-800)/.5);
}

.footnotes-container p {
  margin: 0;
}

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';

// Get __dirname equivalent in ES modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// read mint.json and parse navigation structure
function getMintPaths() {
    const mintJson = JSON.parse(fs.readFileSync('mint.json', 'utf8'));
    const paths = new Set();

    function extractPaths(items) {
        if (!Array.isArray(items)) return;
        
        items.forEach(item => {
            if (typeof item === 'string') {
                paths.add(item + '.mdx');
            } else if (item.pages) {
                extractPaths(item.pages);
            } else if (item.group && item.pages) {
                extractPaths(item.pages);
            }
        });
    }

    extractPaths(mintJson.navigation);
    return paths;
}

// get all mdx files from the filesystem
function getFsFiles(dir = '.', files = new Map()) {
    const items = fs.readdirSync(dir);
    
    for (const item of items) {
        const fullPath = path.join(dir, item);
        const stat = fs.statSync(fullPath);
        
        if (stat.isDirectory() && !item.startsWith('.') && !['fonts', 'images'].includes(item)) {
            getFsFiles(fullPath, files);
        } else if (item.endsWith('.mdx')) {
            // store both the relative path and full path
            files.set(fullPath.slice(2), fullPath);
        }
    }
    
    return files;
}

// ensure directory exists
function ensureDir(dirPath) {
    if (!fs.existsSync(dirPath)) {
        fs.mkdirSync(dirPath, { recursive: true });
    }
}

// move file to correct location
function moveFile(fromPath, toPath) {
    const targetDir = path.dirname(toPath);
    ensureDir(targetDir);
    
    try {
        fs.renameSync(fromPath, toPath);
        console.log(`  moved: ${fromPath} -> ${toPath}`);
    } catch (err) {
        console.error(`  failed to move ${fromPath}: ${err.message}`);
    }
}

// fix file structure based on mint.json
function fixStructure(fsFiles, mintPaths) {
    console.log('=== RESTRUCTURING FILES ===\n');
    
    // create a map of lowercase paths to actual paths for case-insensitive matching
    const lowerCaseMap = new Map();
    for (const [relativePath, fullPath] of fsFiles.entries()) {
        lowerCaseMap.set(relativePath.toLowerCase(), { relative: relativePath, full: fullPath });
    }
    
    // process each path from mint.json
    for (const mintPath of mintPaths) {
        const lowerMintPath = mintPath.toLowerCase();
        const fsFile = lowerCaseMap.get(lowerMintPath);
        
        if (fsFile) {
            // if file exists but in wrong location/case, move it
            if (fsFile.relative !== mintPath) {
                moveFile(fsFile.full, mintPath);
            }
            // remove from map so we know what's left over
            lowerCaseMap.delete(lowerMintPath);
        } else {
            console.log(`  missing: ${mintPath}`);
        }
    }
    
    // remaining files are unused
    console.log('\nUnused files that could be removed:');
    for (const { relative, full } of lowerCaseMap.values()) {
        console.log(`  ${relative}`);
    }
}

// extract all URLs from mint.json (both navigation and redirects)
function getMintUrls(mintJson) {
    const urls = new Set();

    // extract navigation URLs
    function extractNavigationUrls(items) {
        if (!Array.isArray(items)) return;
        
        items.forEach(item => {
            if (typeof item === 'string') {
                urls.add(item);
            } else if (item.pages) {
                extractNavigationUrls(item.pages);
            } else if (item.group && item.pages) {
                extractNavigationUrls(item.pages);
            }
        });
    }

    extractNavigationUrls(mintJson.navigation);

    // extract redirect URLs
    if (mintJson.redirects) {
        mintJson.redirects.forEach(redirect => {
            urls.add(redirect.source);
            urls.add(redirect.destination);
        });
    }

    return urls;
}

// main logic
function main() {
    const command = process.argv[2];
    const mintPaths = getMintPaths();
    const fsPaths = getFsFiles();
    
    switch (command) {
        case 'diff':
            fixStructure(fsPaths, mintPaths);
            break;
            
        case 'unused':
            console.log('=== UNUSED FILES ===');
            for (const [relativePath] of fsPaths.entries()) {
                if (!mintPaths.has(relativePath)) {
                    console.log(relativePath);
                }
            }
            break;
            
        case 'missing':
            console.log('=== MISSING FILES ===');
            for (const mintPath of mintPaths) {
                if (!fsPaths.has(mintPath)) {
                    console.log(mintPath);
                }
            }
            break;

        case 'compare-mint':
            // read both mint files
            const oldMint = JSON.parse(fs.readFileSync('oldmint.json', 'utf8'));
            const newMint = JSON.parse(fs.readFileSync('mint.json', 'utf8'));

            // get all URLs from both files
            const oldUrls = getMintUrls(oldMint);
            const newUrls = getMintUrls(newMint);

            // find URLs that exist in old but not in new
            console.log('=== MISSING URLs IN NEW MINT.JSON ===\n');
            for (const url of oldUrls) {
                if (!newUrls.has(url)) {
                    console.log(url);
                }
            }
            break;
            
        default:
            console.log('Usage: node docs-validator.js [diff|unused|missing|compare-mint]');
            console.log('  diff         - restructure files to match mint.json');
            console.log('  unused       - show files not referenced in mint.json');
            console.log('  missing      - show paths in mint.json with no file');
            console.log('  compare-mint - show URLs from oldmint.json missing in mint.json');
            process.exit(1);
    }
}

main(); 

Options

Ask questions, explore, and find information in your codebase using Cursor's built-in search tools.

Cursor – Ask mode

Ask mode

Cursor

AI-powered IDE with Chat, Tab, and Agent for intelligent code development

Cursor – Welcome to Cursor

Welcome to Cursor

Learn how to use Cursor's core features: Tab completion, Chat for code queries, and Agent for assistance

Cursor – Introduction

Introduction

Learn how to install, set up, and use Cursor with AI features like Chat, Tab, and Composer

Cursor – Installation

Installation

Frequently asked questions about Cursor's features, language support, models, and usage

Cursor – FAQ

Learn how to generate Git commit messages automatically in Cursor using the sparkle icon or shortcuts

Cursor – AI Commit Message

AI Commit Message

A guide to using Notepads in Cursor for sharing context between Composers and Chat interactions

Cursor – Notepads (Beta)

Notepads (Beta)

A comprehensive guide to Cursor keyboard shortcuts for Chat, Composer, Tab and Agent

Cursor – Keyboard Shortcuts

Keyboard Shortcuts

Learn how to index your codebase in Cursor for more accurate AI assistance and search results

Cursor – Codebase Indexing

Codebase Indexing

Learn how to customize AI behavior in Cursor using project-specific and global rules

Cursor – Rules for AI

Rules for AI

Learn how to use .cursorignore and .cursorindexingignore to control file access and indexing in Cursor

Cursor – Ignore Files

Ignore Files

Learn how to add and use custom MCP tools within Cursor

Cursor – Model Context Protocol

Model Context Protocol

Learn about Cursor's pricing plans, usage limits, request pools, and billing information

Cursor – Plans & Usage

Plans & Usage

Learn how to manage billing, usage pricing, and team settings in the dashboard for different plans

Cursor – Dashboard

Dashboard

Guide to Cursor billing: manage subscriptions, seats, cycles, and payments through Stripe portal

Cursor – Billing

Billing

Cursor – Pricing

Pricing

A guide to Cursor's privacy settings, data handling, and code indexing with Privacy Mode option

Cursor – Privacy & Security

Privacy & Security

Cursor offers a variety of frontier models for use with Chat and ⌘K different pricing tiers

Cursor offers a variety of frontier models for use with Chat and ⌘K

Cursor – Models

Models

Learn how to use your own API keys in Cursor for OpenAI, Anthropic, Google, and Azure LLM providers

Cursor – Custom API Keys

Custom API Keys

Access experimental features and early releases in Cursor

Cursor – Early Access Program

Early Access Program

Guide for troubleshooting common Cursor app issues including updates, login, and connectivity problems

Cursor – Common Issues

Common Issues

Technical guide for gathering logs, errors and system info when reporting Cursor issues

Cursor – Troubleshooting Guide

Troubleshooting Guide

Learn how to find and share request IDs in Cursor for better technical support and issue reporting

Cursor – Getting a Request ID

Getting a Request ID

globe

newspaper

headset

Website

Forum

Get Help

Download

Login

Migrate from VS Code to Cursor in minutes

Cursor – Migrate from VS Code

Migrate from VS Code

Learn how to customize Cursor to replicate your JetBrains IDE experience

Cursor – Migrate from JetBrains IDEs

Migrate from JetBrains IDEs

A comprehensive guide to setting up the perfect Python development environment in Cursor

Cursor – Python

Python

Learn how to setup Cursor for JavaScript & TypeScript

Cursor – JavaScript & TypeScript

JavaScript & TypeScript

Cursor – iOS & macOS (Swift)

iOS & macOS (Swift)

Migrate from JetBrains IDEs to Cursor in minutes

Cursor – Java

Java

AI-powered code autocomplete that suggests edits and multi-line changes based on your recent work

Cursor – Overview

Overview

Learn how Cursor's code editing capabilities surpass GitHub Copilot with multi-character & instructional edits

Cursor – Tab vs GitHub Copilot

Tab vs GitHub Copilot

Auto-import feature in Tab helps add module imports automatically in TypeScript and Python projects

Cursor – Auto-import

Auto-import

Learn to navigate code efficiently using Tab in peek views, prediction, and partial accepts

Cursor – Advanced Features

Advanced Features

Chat is where you can ask questions, do small and large multi-file edits and run agents

Default mode in Cursor, equipped with all tools to efficiently handle a wide range of coding tasks.

Cursor – Agent mode

Agent mode

Cursor – Custom modes

Custom modes

Cursor – Tools

Tools

Learn how to apply, accept, or reject code suggestions from chat using Cursor's Apply feature

Cursor – Apply

Apply

Learn how to use Cmd/Ctrl K in Cursor to generate, edit code and ask questions with the Prompt Bar

Use Ctrl/⌘ K in Cursor terminal to generate and run commands through a prompt bar interface

Cursor – Terminal Cmd K

Terminal Cmd K

Overview of all @ symbols available in Cursor for context and commands

Learn how to reference files using @ in Cursor's Chat and Cmd K, with preview and chunking features

Cursor – @Files

@Files

Reference folders as context in Chat & Composer for enhanced AI conversations

Cursor – @Folders

@Folders

Learn to reference code using @Code symbol and keyboard shortcuts for adding code to Chat or Edit

Cursor – @Code

@Code

Learn how to use, add, and manage custom documentation as context in Cursor using @Docs

Cursor – @Docs

@Docs

Learn how to use @Git in Cursor's Chat to analyze diffs, find bugs, and generate commit messages

Cursor – @Git

@Git

@Web command searches the internet automatically to find relevant context for Cursor queries

Cursor – @Web

@Web

Add nearby code definitions to Cmd K context using the @Definitions symbol

Cursor – @Definitions

@Definitions

Use web content as context by linking to external websites and resources

Cursor – @Link

@Link

Access and reference linting errors in your codebase

Cursor – @Lint Errors

@Lint Errors

Access and reference recent changes in your workspace

Cursor – @Recent Changes

@Recent Changes

Work with and reference Cursor rules in your project

Cursor – @Cursor Rules

@Cursor Rules

Reference and include notepads as context in Cursor

Cursor – @Notepads

@Notepads

Reference summarized versions of your previous Composer sessions as context in new conversations

Cursor – @Summarized Composers

@Summarized Composers

Use # to select files and @ for context control when chatting with AI agents

Cursor – #Files

#Files

Use / to reference open editor tabs and add them as context when composing chats with the AI agent

Cursor – /command

/command

Learn how to create and manage a business team: setup, invite members, and configure SSO options

Cursor – Get Started

Get Started

Learn about team roles, member management, SSO, usage controls, and billing for organizational teams

Cursor – Members + Roles

Members + Roles

Track team metrics including usage stats, per-user activity, and active user counts from the dashboard

Cursor – Analytics

Analytics

Learn how to set up SAML 2.0 Single Sign-On (SSO) for secure team authentication in Cursor

Get Started

Guides

Editor

Context

Account

Settings

Troubleshooting

Ask mode

Options

Get Started

Guides

Editor

Context

Account

Settings

Troubleshooting

​Options

Options