::-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;
}

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

Cursor – Pricing

Pricing

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

AI assistant that uses tools and reasoning to perform coding tasks with minimal supervision

Cursor – Agent

Agent

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 feature

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

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

Cursor – Privacy + Security

Privacy + Security

Switch between AI models in Cursor using Chat, Composer, Tab, or Agent with different pricing tiers

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 app 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

Unified AI interface that combines Ask, Edit, and Agent modes to help write, edit, and understand code directly in your editor

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

Learn how Chat processes codebase queries using gathering, reranking, reasoning, and generation steps

Cursor – @Codebase

@Codebase

@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

Pricing