::-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(/cursor/"/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(/cursor/"/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(); 

Cursor – Pricing

定价

Cursor

AI驱动的集成开发环境，具备聊天、标签页和智能代理功能，助力智能化代码开发

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

Cursor – Welcome to Cursor

欢迎使用Cursor

学习如何使用Cursor的核心功能：Tab自动补全、代码查询聊天功能以及获取助手代理支持

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

Cursor – Introduction

简介

了解如何安装、设置和使用Cursor，包括其AI功能如聊天、标签页和编辑器

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

Cursor – Installation

安装

关于Cursor功能、语言支持、模型和使用的常见问题

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

Cursor – FAQ

常见问题

了解如何在Cursor中通过点击星标图标或使用快捷键自动生成Git提交信息

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

Cursor – AI Commit Message

AI 提交信息

Cursor中使用记事本在Composer与聊天交互间共享上下文的指南

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

Cursor – Notepads (Beta)

记事本（测试版）

Cursor快捷键全面指南：聊天、编辑器、标签页与智能助手

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

Cursor – Keyboard Shortcuts

键盘快捷键

了解如何在Cursor中为代码库建立索引，以获得更精准的AI辅助和搜索结果

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

Cursor – Codebase Indexing

代码库索引

了解如何在Cursor中通过项目特定规则和全局规则自定义AI行为

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

Cursor – Rules for AI

AI使用规则

了解如何使用.cursorignore和.cursorindexingignore文件来控制Cursor中的文件访问与索引功能

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

Cursor – Ignore Files

忽略文件

了解如何在Cursor中添加和使用自定义MCP工具

Learn how to add and use custom MCP tools within Cursor

Cursor – Model Context Protocol

模型上下文协议

了解Cursor的定价方案、使用限制、请求池和账单信息

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

Cursor – Plans & Usage

计划与用量

了解如何在仪表板中管理不同方案的账单、使用定价和团队设置

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

Cursor – Dashboard

仪表盘

Cursor账单指南：通过Stripe门户管理订阅、席位、周期和付款

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

Cursor – Billing

账单

Cursor隐私设置指南：包含隐私模式选项的数据处理与代码索引说明

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

Cursor – Privacy & Security

隐私与安全

Cursor提供多种前沿模型，可用于聊天和⌘K不同定价层级

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

Cursor – Models

模型

了解如何在Cursor中使用您自己的API密钥，支持OpenAI、Anthropic、Google和Azure等LLM提供商

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

Cursor – Custom API Keys

自定义API密钥

在Cursor中访问实验性功能和早期版本

Access experimental features and early releases in Cursor

Cursor – Early Access Program

早期访问计划

Cursor应用常见问题排查指南，包括更新、登录和连接问题

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

Cursor – Common Issues

收集日志、错误和系统信息的技术指南（用于报告Cursor问题时）

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

Cursor – Troubleshooting Guide

故障排除指南

了解如何在Cursor中查找和共享请求ID，以获得更好的技术支持与问题报告

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

Cursor – Getting a Request ID

获取请求ID

globe

newspaper

headset

Website

Forum

Get Help

Download

Login

Migrate from VS Code to Cursor in minutes

Cursor – Migrate from VS Code

从VS Code迁移

了解如何自定义Cursor以复现您在JetBrains IDE中的使用体验

Learn how to customize Cursor to replicate your JetBrains IDE experience

Cursor – Migrate from JetBrains IDEs

从JetBrains IDE迁移

在Cursor中设置完美Python开发环境的全面指南

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

Cursor – Python

Python

了解如何为JavaScript和TypeScript设置Cursor

Learn how to setup Cursor for JavaScript & TypeScript

Cursor – JavaScript & TypeScript

JavaScript & TypeScript

Cursor – iOS & macOS (Swift)

iOS 和 macOS (Swift)

从JetBrains IDE迁移到Cursor只需几分钟

Migrate from JetBrains IDEs to Cursor in minutes

Cursor – Java

Java

AI驱动的代码自动补全，根据您最近的工作建议编辑和多行更改

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

Cursor – Overview

概述

了解Cursor的代码编辑功能如何通过多字符和指令编辑超越GitHub Copilot

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

Cursor – Tab vs GitHub Copilot

选项卡 vs GitHub Copilot

Tab中的自动导入功能可帮助在TypeScript和Python项目中自动添加模块导入

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

Cursor – Auto-import

自动导入

学会高效浏览代码 - 使用Tab键在预览视图、预测和部分接受功能中导航

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

Cursor – Advanced Features

高级功能

聊天功能可以让您提问、进行大小规模的多文件编辑以及运行代理程序

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

Cursor中的默认模式，配备了所有工具，可高效处理各种编码任务。

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

Cursor – Agent mode

代理模式

使用Cursor内置的搜索工具，在代码库中提问、探索和查找信息。

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

Cursor – Ask mode

提问模式

Cursor – Custom modes

自定义模式

Cursor – Tools

工具

了解如何使用Cursor的Apply功能来应用、接受或拒绝来自聊天的代码建议

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

Cursor – Apply

应用

了解如何在Cursor中使用Cmd/Ctrl K通过提示栏生成、编辑代码和提问

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

在Cursor终端中使用Ctrl/⌘ K通过提示栏界面生成并运行命令

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

Cursor – Terminal Cmd K

终端命令 K

Cursor中所有可用@符号的概述（用于上下文和命令）

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

了解如何在Cursor的Chat和Cmd K中使用@引用文件，支持预览和分块功能

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

Cursor – @Files

@文件

在聊天和作曲器中引用文件夹作为上下文，以增强AI对话体验

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

Cursor – @Folders

@文件夹

学习使用@Code符号和键盘快捷键来引用代码，将其添加到聊天或编辑中

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

Cursor – @Code

@代码

了解如何在Cursor中使用@Docs添加和管理自定义文档作为上下文

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

Cursor – @Docs

@文档

学习如何在Cursor的聊天功能中使用@Git来分析代码差异、查找错误并生成提交信息

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

Cursor – @Git

@Git

@Web 命令会自动搜索互联网，为 Cursor 查询寻找相关上下文

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

Cursor – @Web

@Web

使用@Definitions符号将附近的代码定义添加到Cmd K上下文中

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

Cursor – @Definitions

@定义

使用网页内容作为上下文，通过链接外部网站和资源

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

Cursor – @Link

@链接

访问和引用代码库中的linting错误

Access and reference linting errors in your codebase

Cursor – @Lint Errors

@Lint错误

访问和引用工作区中的最近更改

Access and reference recent changes in your workspace

Cursor – @Recent Changes

@最近更改

在您的项目中使用和引用Cursor规则

Work with and reference Cursor rules in your project

Get Started

Guides

Editor

Context

Account

Settings

Troubleshooting

Pricing