::-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),
.full-width-table table th:nth-child(5) {
  text-align: center;
}

@media (max-width: 640px) {
  .full-width-table table th:nth-child(2),
  .full-width-table table td:nth-child(2) {
    display: none;
  }
}



: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;
  grid-auto-flow: row;
  margin-top: -14px;
  padding-bottom: 1rem;
  border-bottom: 1px solid rgb(var(--gray-800)/.5);
  line-height: 1.6;
}

@media (max-width: 640px) {
  .footnotes-container {
    grid-template-columns: 1fr;
  }
}


.footnotes-container p {
  font-size: 0.8rem;
  opacity: 0.5;
  margin: 0 0 0 0.35em;
}

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

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(); 

What is a request ID?

Getting your current request ID

Getting a request ID from a previous action

How do I find a request ID?

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

Cursor

Get started with Cursor IDE & learn core features: Tab completion, Chat AI pair programming, and Cmd-K editing

Cursor – Welcome to Cursor

Welcome to Cursor

Learn about Cursor's core AI features, settings, and customization options for powerful code development.

Cursor – Introduction

Introduction

Guide to installing Cursor, configuring initial settings, and migrating from other code editors

Cursor – Installation

Installation

Common questions about language support, models, project limits, and data management in Cursor with troubleshooting help

Cursor – FAQ

Learn how to generate contextual Git commit messages automatically using Cursor's 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)

Complete reference for all keyboard shortcuts in Cursor, including Chat, Tab, Terminal and code selection commands

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

Guide to customizing AI behavior in Cursor using project-specific and global rules for model responses

Cursor – Rules for AI

Rules for AI

Control which files Cursor's AI features and indexing can access using .cursorignore and .cursorindexingignore

Cursor – Ignore Files

Ignore Files

Connect external tools and data sources to Cursor using the Model Context Protocol (MCP) plugin system

Cursor – Model Context Protocol

Model Context Protocol

Guide to Cursor usage tiers, request types, quotas, and billing options for premium models and team accounts

Cursor – Plans & Usage

Plans & Usage

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

Cursor – Dashboard

Dashboard

Complete guide to managing Cursor billing: subscriptions, refunds, cycles and access through Stripe portal

Cursor – Billing

Billing

Cursor – Pricing

Pricing

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

Cursor – Privacy & Security

Privacy & Security

Comprehensive guide to Cursor's models: features, pricing, context windows, and hosting details for Chat and CMD+K

Cursor – Models

Models

Configure custom API keys for OpenAI, Anthropic, Google and Azure to use your own LLM provider accounts in Cursor

Cursor – Custom API Keys

Custom API Keys

Learn how to join Cursor's Early Access Program to test experimental features and provide feedback

Cursor – Early Access Program

Early Access Program

Guide to resolving common Cursor issues including networking, resource usage, SSH connections, and general FAQs

Cursor – Common Issues

Common Issues

Guide to troubleshooting common Cursor issues, resetting app data, and submitting detailed bug reports

Cursor – Troubleshooting Guide

Troubleshooting Guide

globe

newspaper

headset

Website

Forum

Get Help

Download

Login

Guide to migrating VS Code settings, extensions, and profiles to Cursor using one-click import or manual methods

Cursor – Migrate from VS Code

Migrate from VS Code

Guide to migrating from JetBrains IDEs to Cursor: setup extensions, themes, shortcuts, and language-specific tools

Cursor – Migrate from JetBrains IDEs

Migrate from JetBrains IDEs

Comprehensive guide to setting up Python development in Cursor with essential extensions, linting and tools

Cursor – Python

Python

Complete guide to JavaScript & TypeScript development in Cursor, featuring extensions, AI tools, and framework support

Cursor – JavaScript & TypeScript

JavaScript & TypeScript

Guide to integrating Cursor with Swift development workflows using Xcode, hot reloading, and Sweetpad tools

Cursor – iOS & macOS (Swift)

iOS & macOS (Swift)

Complete guide to setting up Java development in Cursor: JDK setup, extensions, debugging, and Maven/Gradle integration

Cursor – Java

Java

Learn how Tab uses AI to suggest multi-line edits, code fixes, and context-aware completions directly in the editor

Cursor – Overview

Overview

Compares Cursor's multi-line edits and instruction-based completions to GitHub Copilot's single-line insertions

Cursor – Tab vs GitHub Copilot

Tab vs GitHub Copilot

Learn how Cursor's Tab feature automates module imports in TypeScript and Python projects while you code

Cursor – Auto-import

Auto-import

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

Cursor – Advanced Features

Advanced Features

Natural language interface for exploring, editing, and managing code with contextual AI assistance in Chat mode

Autonomous AI coding agent that independently explores, plans, and executes complex codebase changes with full tools

Cursor – Agent Mode

Agent Mode

Ask mode lets you explore and learn about codebases through AI search and queries without making changes

Cursor – Ask mode

Ask mode

Make precise code changes with explicit file targeting - a focused editing mode with user-controlled tooling

Cursor – Manual Mode

Manual Mode

Create custom Cursor modes with tailored tools and prompts to personalize AI assistance for specific workflows

Cursor – Custom Modes

Custom Modes

A guide to all available tools in Cursor's Chat modes for searching, editing, and interacting with your codebase

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 Cmd K in Cursor terminal to generate and run commands through a prompt bar interface

Cursor – Terminal Cmd K

Terminal Cmd K

Guide to using @ symbols in Cursor for referencing code, files, documentation and other context in chats

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 how to reference code snippets in Cursor using @Code symbol and keyboard shortcuts for adding to Chat

Cursor – @Code

@Code

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

Cursor – @Docs

@Docs

Reference Git commits, diffs, and PRs as context in Cursor Chat to analyze changes and generate commit messages

Cursor – @Git

@Git

Enables web search to dynamically add recent online information and documentation as context in Cursor commands

Cursor – @Web

@Web

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

Cursor – @Definitions

@Definitions

Learn how to include and manage web links as context in Cursor's AI features by pasting URLs

Cursor – @Link

@Link

Access and reference linting errors in your codebase

Cursor – @Lint Errors

@Lint Errors

Reference recently modified code as context for AI chat using the @Recent Changes symbol

Cursor – @Recent Changes

@Recent Changes

Reference and apply project-specific rules and guidelines using the @Cursor Rules symbol in chats and prompts

Cursor – @Cursor Rules

@Cursor Rules

Reference and include notepad contexts in Cursor conversations for reusable development workflows

Cursor – @Notepads

@Notepads

Include context from previous Composer sessions as summarized references when starting related tasks

Cursor – @Summarized Composers

@Summarized Composers

Select specific files using # prefix in Cursor's input fields, works alongside @ context controls for precision

Cursor – #Files

#Files

Use / commands to reference open editor tabs and add them as context for conversations with Cursor AI

Cursor – /command

/command

Guide to create and manage Cursor business teams with SSO, enterprise features, and MDM deployment options

Cursor – Get Started

Get Started

Learn about team roles, member management, SSO options, 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

Guide to setting up SAML 2.0 SSO authentication with your identity provider in Cursor for team accounts

Get Started

Guides

Editor

Context

Account

Settings

Troubleshooting

Getting a Request ID

What is a request ID?

How do I find a request ID?

Getting your current request ID

Getting a request ID from a previous action

Get Started

Guides

Editor

Context

Account

Settings

Troubleshooting

​What is a request ID?

​How do I find a request ID?

​Getting your current request ID

​Getting a request ID from a previous action

What is a request ID?

How do I find a request ID?

Getting your current request ID

Getting a request ID from a previous action