请参考：AI - CurSor概述，安装注册（一）

一、CurSor三大核心AI功能

1、Tab键：智能小助手

Tab官网文档：https://cursor.com/cn/docs/tab/overview

Cursor 的 Tab 键具有强大的代码自动补全功能，基于 AI 模型，能根据代码上下文自动预测并生成代码补全建议和代码修复重构，还可用于导航代码等！

Tab 键接受建议，也可以通过按 Esc 键拒绝建议。要逐字部分接受建议，请按 Ctrl/⌘ + →。

Tab 是用于自动补全的专用 Cursor 模型。你用得越多，它就会变得越聪明，因为你通过接受 Tab 或拒绝 Esc 的建议来传达意图。使用 Tab，你可以：

• 一次修改多行
• 自动补全缺失的 import 语句
• 在文件内及跨文件跳转以进行协同编辑
• 基于最近的更改、linter 错误和已接受的编辑获得建议

设置

设置	说明
Cursor Tab	基于最近编辑，在光标处提供具备上下文感知的多行建议
部分接受	通过 Ctrl Right 接受建议中的下一个词
评论时显示建议	在注释块内启用 Tab
仅空白字符建议	允许仅影响格式的编辑
Imports	启用 TypeScript 自动导入
Python 自动导入（测试版）	为 Python 项目启用自动导入

1.1、单行/多行代码补全

已有代码片段：

//需求：写一个工具类计算数组平均值
public class ArrayUtils {
   // 按tab会完成补全
}

按tab键 → Cursor 自动生成代码：

//需求：写一个工具类计算数组平均值
public class ArrayUtils {

    // main方法调用average方法
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        double average = average(array);
        System.out.println("平均值：" + average);
    }

   // 按tab会完成补全average方法
   public static double average(int[] array) {
     if (array == null || array.length == 0) {
       return 0.0;
     }
     int sum = 0;
     for (int i = 0; i < array.length; i++) {
       sum += array[i];
     }
     return (double) sum / array.length;
   }
}

接受代码效果，右上角点击“Run”运行，在控制台查看效果

1.2、智能代码重写

已有代码片段：

import java.util.List;
import java.util.Arrays;
import java.util.ArrayList;

public class ArrayUtils {

    public void arrayFor() {    
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> evenNumbers = new ArrayList<>();
        for (int num : numbers) {
            if (num % 2 == 0) {
                evenNumbers.add(num);
            }
        }
    }
}

快速修复，帮助导包

按Tab键 → 自动补全：

public void arrayFor() {   
     //在循环上方添加注释：// 使用 Stream 重构
     //光标放在循环代码块的任意位置，按 Tab 键 重构
     List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
     List<Integer> evenNumbers = numbers.stream().filter(num -> num % 2 == 0).collect(Collectors.toList());
    
     //在循环上方添加注释：// 使用 Stream 重构
     //  for (int num : numbers) {
    //     if (num % 2 == 0) {
    //         evenNumbers.add(num);
    //     }
    //  }
   }

1.3、多行协同优化

Cursor 的 多行协同优化 核心能力：多行代码，一次性完成 语法升级、结构重组、安全修复。

多行数据联想

// 姓名
String name = "张三"; 
//tab 会继续联想变量类型

多行批量修改

private int add(int a, int b) {
    //代码添加注释
    System.out.println("第一次输出");
    return a + b;
}

1.4、光标位置预测

1.5、接受，接受部分和拒绝

public class Student {
    private String name;
    private int  age;
    //tab 
    //tab 接收完整补全
    //ctrl + -> 部分和逐步接收补全 [需要开启部分补全配置]
    //esc 或者 继续输入 拒绝补全
}

1.6、Tab相关配置说明

配置修改位置： cursor settings > features（老版本有，新版本略掉） > tab

• A powerful Copilot replacement that can suggest changes across multiple lines…

作用：启用 / 禁用 Cursor Tab 功能。

通俗理解：相当于 “总开关”，勾选后才能用 Tab 键触发 AI 代码建议（如多行补全、智能续写）；取消勾选则 Tab 仅作普通缩进。

• Accept the next word of a suggestion via Ctrl+RightArrow

作用：开启后，可用 Ctrl+→（Windows/Linux）或 ⌘+→（Mac）逐个单词接受 AI 建议。

通俗理解：AI 给的建议很长时，不想全要？开这个功能，按快捷键 “挑着用”。

场景：比如 AI 建议 const fullName = firstName + " " + lastName;，但你只想用 firstName + " " + lastName 部分，就可通过该快捷键拆分接受。

• Enable Cursor Tab suggestions in comments

作用：让 AI 在注释内容里也提供 Tab 建议。

通俗理解：写注释时，AI 帮你补全思路！比如输入 // 实现冒泡排序的步骤：，按 Tab 自动续写步骤说明。

• Show whitespace only Cursor Tab suggestions

作用：控制是否显示仅包含空白（空格、换行）的 AI 建议。

通俗理解：这个配置项决定了 当按 Tab 时，是否让那些 “只调整空格、换行、缩进（没有实际代码逻辑变化）” 的建议显示出来。

如：

public class Demo {
public void test() {
System.out.println("Hello");
  if (true) {
System.out.println("World");
  }
}
}

• 勾选：把光标放在混乱的代码里（比如 public void test() { 这行后面） tab 会有修改建议
• 不勾选：把光标放在混乱的代码里（比如 public void test() { 这行后面） tab不会有修改建议

• Tab to import necessary modules with Cursor Tab. Only supports TypeScript

作用：在 TypeScript 中，写代码时缺模块，按 Tab 自动帮你导入依赖。

• Enable auto import for Python. This is a beta feature.

作用：（测试版）为 Python 开启类似功能，按 Tab 自动导入缺失模块。

2、Chat: 对话模式

Chat（以前称为“Composer”）是 Cursor 的 AI 助手，位于的侧边栏中，可让通过自然语言与代码库进行交互。可以提出问题、请求代码编辑、获取终端命令建议等 - 所有这些都无需切换上下文。

Chat官网文档：https://cursor.com/cn/docs/agent/overview

Cursor Chat 核心功能解析

1. 代码库智能操作与功能实现 - 深度理解项目架构与代码逻辑，支持直接对代码库进行增删改操作，高效实现新功能需求。无论是添加支付模块、集成第三方API，还是扩展业务逻辑，均可通过自然语言指令触发自动化代码生成与修改，大幅提升开发效率。
2. 全链路代码重构与架构优化 - 基于对代码库组件依赖关系的分析，提供系统化重构方案。可实现单体架构向微服务拆分、技术栈升级（如Python 2→3）、反模式修复（如冗余代码提取）等复杂操作，同时自动维护跨文件引用关系，确保重构过程的稳定性。
3. 项目自动化搭建与初始化 - 支持从零构建完整项目框架：根据技术栈需求（如React+Node.js、Spring Boot+Vue）自动生成标准化项目结构，配置依赖管理文件（package.json/maven pom.xml），甚至编写基础服务代码（如用户认证模块、数据库连接层），帮助开发者快速进入业务编码阶段。
4. 智能错误定位与代码修复 - 基于错误日志（如编译报错、运行时异常）自动定位问题根源，提供针对性修复方案。可直接修改代码中的语法错误（如TypeScript类型不匹配）、逻辑漏洞（如空指针异常）或依赖冲突，同步生成修改前后的diff对比，确保修复过程透明可控。

2.1、快速开始

使用 ⌘+L （Mac） 或 Ctrl+L （Windows/Linux） 访问侧边栏中的聊天。用自然语言输入我们的请求，AI 将做出相应的响应。

注： 与Chat 对话时，建议采用清晰、具体的语言格式，最好包含任务类型、上下文描述和具体要求。

以下是几个参考模板：

• 代码生成类

[任务类型]：请生成一个 {功能描述} 的 {编程语言/框架} 实现

[具体要求]：
1. 使用 {特定技术/库}（如React、Nodejs等）
2. 包含 {特定功能点}（如用户认证、数据可视化）
3. 符合 {编码规范/设计模式}（如 SOLID 原则、TypeScript 类型约束）

请生成一个学习计划页面的HTML+CSS+JavaScript实现

[具体要求]：
1. 使用Tailwind CSS v3和Font Awesome
2. 包含任务添加、编辑、删除功能
3. 包含日历视图展示学习计划
4. 包含学习进度可视化图表
5. 符合现代UI设计原则和响应式设计
6. 具有平滑的动画和交互效果

生成代码如下：

<!DOCTYPE html>
<html lang="zh-CN">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Learning Planner</title>
    <link
      rel="stylesheet"
      href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css"
      integrity="sha512-+M39enPShDG4UeLOzbYmxn/GG5I1cN59aaT0ou6l2OpTkCzsZou8BlAf940P5cDFuj5jI3OZSaUD0Yz4I+p3CQ=="
      crossorigin="anonymous"
      referrerpolicy="no-referrer"
    />
    <script src="https://cdn.tailwindcss.com"></script>
    <script>
      tailwind.config = {
        theme: {
          extend: {
            colors: {
              obsidian: "#0c0f1a",
              neon: "#14b8a6",
              accent: "#6366f1",
            },
          },
        },
      };
    </script>
  </head>
  <body class="min-h-screen bg-gradient-to-b from-obsidian to-slate-900 text-slate-100">
    <div class="relative overflow-hidden">
      <div class="absolute inset-0 pointer-events-none opacity-40">
        <div class="h-full w-full bg-[radial-gradient(circle_at_top,rgba(80,200,255,.25),transparent_45%)]"></div>
      </div>

      <header class="relative z-10 px-6 py-12 lg:px-16">
        <div class="max-w-5xl">
          <p class="inline-flex items-center gap-2 text-sm uppercase tracking-[0.3em] text-teal-300">
            <span class="h-px w-6 bg-teal-300"></span> Learning Journey
          </p>
          <h1 class="mt-4 text-4xl font-bold leading-tight text-white md:text-5xl lg:text-6xl">
            个性化学习计划
          </h1>
          <p class="mt-4 text-lg text-slate-300 md:w-3/4">
            快速整理你的学习任务，掌握每日安排，并通过可视化图表实时追踪进度。
          </p>
          <div class="mt-6 flex flex-wrap gap-3">
            <span class="inline-flex items-center gap-2 rounded-full border border-white/20 px-4 py-2 text-sm text-white/80">
              <i class="fa-solid fa-rocket text-accent"></i> 持续迭代
            </span>
            <span class="inline-flex items-center gap-2 rounded-full border border-white/20 px-4 py-2 text-sm text-white/80">
              <i class="fa-solid fa-bolt text-neon"></i> 高效执行
            </span>
          </div>
        </div>
      </header>

      <main class="relative z-10 px-6 pb-16 lg:px-16">
        <div class="grid gap-8 lg:grid-cols-3">
          <section class="lg:col-span-2 space-y-6">
            <div class="rounded-3xl border border-white/10 bg-white/5 p-6 backdrop-blur">
              <div class="flex items-center gap-3">
                <div class="flex h-12 w-12 items-center justify-center rounded-2xl bg-neon/10 text-neon">
                  <i class="fa-solid fa-list-check text-xl"></i>
                </div>
                <div>
                  <h2 class="text-xl font-semibold text-white">任务管理</h2>
                  <p class="text-sm text-slate-400">添加、编辑、删除学习任务</p>
                </div>
              </div>

              <form id="task-form" class="mt-6 grid gap-4 md:grid-cols-2">
                <div class="flex flex-col gap-2">
                  <label class="text-sm text-slate-300">任务名称</label>
                  <input
                    id="task-title"
                    type="text"
                    placeholder="如：完成线性代数第五章"
                    class="rounded-xl border border-white/10 bg-white/5 px-4 py-3 text-sm text-white placeholder:text-slate-500 focus:border-accent focus:outline-none focus:ring-2 focus:ring-accent/40"
                    required
                  />
                </div>
                <div class="flex flex-col gap-2">
                  <label class="text-sm text-slate-300">学习类型</label>
                  <select
                    id="task-category"
                    class="rounded-xl border border-white/10 bg-white/5 px-4 py-3 text-sm text-white focus:border-accent focus:outline-none focus:ring-2 focus:ring-accent/40"
                  >
                    <option value="理论">理论</option>
                    <option value="实践">实践</option>
                    <option value="复习">复习</option>
                    <option value="项目">项目</option>
                  </select>
                </div>
                <div class="flex flex-col gap-2">
                  <label class="text-sm text-slate-300">计划日期</label>
                  <input
                    id="task-date"
                    type="date"
                    class="rounded-xl border border-white/10 bg-white/5 px-4 py-3 text-sm text-white focus:border-accent focus:outline-none focus:ring-2 focus:ring-accent/40"
                    required
                  />
                </div>
                <div class="flex flex-col gap-2">
                  <label class="text-sm text-slate-300">完成度 (%)</label>
                  <input
                    id="task-progress"
                    type="number"
                    min="0"
                    max="100"
                    value="0"
                    class="rounded-xl border border-white/10 bg-white/5 px-4 py-3 text-sm text-white focus:border-accent focus:outline-none focus:ring-2 focus:ring-accent/40"
                  />
                </div>
                <div class="md:col-span-2 flex flex-wrap gap-3">
                  <button
                    id="submit-btn"
                    class="group inline-flex flex-1 items-center justify-center gap-2 rounded-2xl bg-gradient-to-r from-accent to-neon px-6 py-3 text-sm font-semibold text-white transition-all duration-300 hover:shadow-lg hover:shadow-accent/40"
                  >
                    <i class="fa-solid fa-plus group-hover:rotate-90 transition-transform"></i>
                    <span>添加任务</span>
                  </button>
                  <button
                    type="reset"
                    id="reset-btn"
                    class="inline-flex items-center gap-2 rounded-2xl border border-white/20 px-6 py-3 text-sm font-semibold text-white/80 transition-all duration-300 hover:bg-white/10"
                  >
                    <i class="fa-solid fa-rotate-left"></i>
                    重置
                  </button>
                </div>
              </form>
            </div>

            <div class="rounded-3xl border border-white/10 bg-white/5 p-6 backdrop-blur">
              <div class="mb-4 flex items-center justify-between">
                <div>
                  <h3 class="text-xl font-semibold text-white">任务列表</h3>
                  <p class="text-sm text-slate-400">点击任务进行编辑或删除</p>
                </div>
                <div class="inline-flex items-center gap-2 rounded-full bg-white/10 px-3 py-1 text-xs text-white/70">
                  <span class="h-2 w-2 rounded-full bg-neon animate-pulse"></span>
                  实时同步
                </div>
              </div>
              <div id="task-list" class="space-y-4"></div>
            </div>
          </section>

          <section class="space-y-6">
            <div class="rounded-3xl border border-white/10 bg-white/5 p-6 backdrop-blur">
              <div class="flex items-center justify-between">
                <div>
                  <h3 class="text-xl font-semibold text-white">学习日历</h3>
                  <p class="text-sm text-slate-400">查看任务分布</p>
                </div>
                <div class="flex gap-2">
                  <button id="prev-month" class="rounded-full border border-white/20 p-2 text-white/70 transition hover:bg-white/10">
                    <i class="fa-solid fa-chevron-left"></i>
                  </button>
                  <button id="next-month" class="rounded-full border border-white/20 p-2 text-white/70 transition hover:bg-white/10">
                    <i class="fa-solid fa-chevron-right"></i>
                  </button>
                </div>
              </div>
              <div class="mt-4 text-center text-sm text-slate-300" id="calendar-label"></div>
              <div class="mt-4 grid grid-cols-7 gap-2 text-center text-xs font-semibold uppercase text-slate-400">
                <span>日</span><span>一</span><span>二</span><span>三</span><span>四</span><span>五</span><span>六</span>
              </div>
              <div id="calendar-grid" class="mt-3 grid grid-cols-7 gap-2 text-center text-sm"></div>
            </div>

            <div class="rounded-3xl border border-white/10 bg-white/5 p-6 backdrop-blur">
              <div class="flex items-center gap-3">
                <div class="flex h-12 w-12 items-center justify-center rounded-2xl bg-accent/10 text-accent">
                  <i class="fa-solid fa-chart-line text-xl"></i>
                </div>
                <div>
                  <h3 class="text-xl font-semibold text-white">学习进度</h3>
                  <p class="text-sm text-slate-400">实时可视化更新</p>
                </div>
              </div>
              <canvas id="progress-chart" class="mt-6"></canvas>
            </div>
          </section>
        </div>
      </main>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
    <script>
      const taskForm = document.getElementById("task-form");
      const titleInput = document.getElementById("task-title");
      const categoryInput = document.getElementById("task-category");
      const dateInput = document.getElementById("task-date");
      const progressInput = document.getElementById("task-progress");
      const taskList = document.getElementById("task-list");
      const submitBtn = document.getElementById("submit-btn");

      const calendarLabel = document.getElementById("calendar-label");
      const calendarGrid = document.getElementById("calendar-grid");
      const prevMonthBtn = document.getElementById("prev-month");
      const nextMonthBtn = document.getElementById("next-month");

      let editingId = null;
      let currentMonth = new Date();

      const tasks = [
        {
          id: crypto.randomUUID(),
          title: "复习微积分专项题库",
          category: "复习",
          date: new Date().toISOString().slice(0, 10),
          progress: 60,
        },
        {
          id: crypto.randomUUID(),
          title: "完成机器学习项目迭代",
          category: "项目",
          date: new Date(Date.now() + 86400000 * 2).toISOString().slice(0, 10),
          progress: 30,
        },
      ];

      const chartCtx = document.getElementById("progress-chart");
      const progressChart = new Chart(chartCtx, {
        type: "doughnut",
        data: {
          labels: ["已完成", "进行中"],
          datasets: [
            {
              data: [0, 100],
              backgroundColor: ["#14b8a6", "#6366f1"],
              borderWidth: 0,
            },
          ],
        },
        options: {
          plugins: {
            legend: {
              labels: { color: "#cbd5f5" },
            },
          },
          cutout: "70%",
        },
      });

      const updateChart = () => {
        const total = tasks.length || 1;
        const done = tasks.reduce((sum, task) => sum + Number(task.progress || 0), 0) / total;
        progressChart.data.datasets[0].data = [done, 100 - done];
        progressChart.update();
      };

      const renderTasks = () => {
        taskList.innerHTML = "";
        if (!tasks.length) {
          taskList.innerHTML =
            '<p class="rounded-2xl border border-white/5 bg-white/5 px-4 py-6 text-center text-sm text-slate-400">暂无任务，添加一个目标开始吧！</p>';
          return;
        }

        tasks
          .slice()
          .sort((a, b) => new Date(a.date) - new Date(b.date))
          .forEach((task) => {
            const wrapper = document.createElement("div");
            wrapper.className =
              "group rounded-2xl border border-white/5 bg-white/5 p-4 transition-all duration-300 hover:-translate-y-1 hover:bg-white/10";
            wrapper.innerHTML = `
              <div class="flex flex-col gap-3 md:flex-row md:items-center md:justify-between">
                <div>
                  <p class="text-sm uppercase tracking-[0.2em] text-slate-400">${task.category}</p>
                  <p class="text-lg font-semibold text-white">${task.title}</p>
                  <p class="text-sm text-slate-400">${task.date}</p>
                </div>
                <div class="flex items-center gap-4">
                  <div class="flex flex-col items-center">
                    <span class="text-xs text-slate-400">完成度</span>
                    <span class="text-2xl font-bold text-neon">${task.progress}%</span>
                  </div>
                  <div class="flex gap-2 text-slate-300">
                    <button data-action="edit" data-id="${task.id}" class="rounded-xl border border-white/10 px-3 py-2 text-sm transition hover:bg-accent/20 hover:text-accent">
                      <i class="fa-solid fa-pen"></i>
                    </button>
                    <button data-action="delete" data-id="${task.id}" class="rounded-xl border border-white/10 px-3 py-2 text-sm transition hover:bg-rose-500/10 hover:text-rose-400">
                      <i class="fa-solid fa-trash"></i>
                    </button>
                  </div>
                </div>
              </div>
            `;
            taskList.appendChild(wrapper);
          });
      };

      const getMonthMatrix = (date) => {
        const year = date.getFullYear();
        const month = date.getMonth();
        const firstDay = new Date(year, month, 1).getDay();
        const daysInMonth = new Date(year, month + 1, 0).getDate();
        const matrix = [];
        let dayCounter = 1 - firstDay;
        while (dayCounter <= daysInMonth) {
          const week = [];
          for (let i = 0; i < 7; i++) {
            if (dayCounter > 0 && dayCounter <= daysInMonth) {
              week.push(new Date(year, month, dayCounter));
            } else {
              week.push(null);
            }
            dayCounter++;
          }
          matrix.push(week);
        }
        return matrix;
      };

      const renderCalendar = () => {
        calendarGrid.innerHTML = "";
        const matrix = getMonthMatrix(currentMonth);
        const monthLabel = `${currentMonth.getFullYear()}年 ${currentMonth.getMonth() + 1}月`;
        calendarLabel.textContent = monthLabel;

        const todayStr = new Date().toISOString().slice(0, 10);
        matrix.forEach((week) => {
          week.forEach((dateObj) => {
            const cell = document.createElement("div");
            if (!dateObj) {
              cell.className = "h-16 rounded-2xl border border-dashed border-white/5";
              calendarGrid.appendChild(cell);
              return;
            }
            const dateStr = dateObj.toISOString().slice(0, 10);
            const dayTasks = tasks.filter((task) => task.date === dateStr);
            const hasTask = dayTasks.length > 0;
            const isToday = dateStr === todayStr;
            cell.className = [
              "relative h-16 rounded-2xl border border-white/5 p-2 transition duration-300",
              hasTask ? "bg-gradient-to-br from-accent/10 to-neon/10" : "bg-white/5",
              isToday ? "ring-2 ring-accent/60" : "",
            ].join(" ");
            cell.innerHTML = `
              <div class="text-right text-xs text-slate-300">${dateObj.getDate()}</div>
              ${
                hasTask
                  ? `<div class="mt-1 flex flex-wrap gap-1">
                      ${dayTasks
                        .map(
                          (task) => `
                            <span class="inline-flex items-center gap-1 rounded-full bg-white/10 px-2 py-0.5 text-[10px] text-white">
                              <i class="fa-solid fa-circle text-[6px]" style="color:${task.category === "项目" ? "#f472b6" : task.category === "实践" ? "#34d399" : "#38bdf8"}"></i>
                              ${task.category}
                            </span>`
                        )
                        .join("")}
                    </div>`
                  : ""
              }
            `;
            cell.title = dayTasks.map((task) => `${task.title} (${task.progress}%)`).join("\\n");
            calendarGrid.appendChild(cell);
          });
        });
      };

      taskList.addEventListener("click", (event) => {
        const button = event.target.closest("button[data-action]");
        if (!button) return;
        const action = button.dataset.action;
        const id = button.dataset.id;
        const taskIndex = tasks.findIndex((task) => task.id === id);
        if (taskIndex === -1) return;

        if (action === "edit") {
          const task = tasks[taskIndex];
          titleInput.value = task.title;
          categoryInput.value = task.category;
          dateInput.value = task.date;
          progressInput.value = task.progress;
          editingId = task.id;
          submitBtn.querySelector("span").textContent = "保存修改";
          submitBtn.classList.add("from-neon", "to-accent");
        } else if (action === "delete") {
          tasks.splice(taskIndex, 1);
          renderTasks();
          renderCalendar();
          updateChart();
        }
      });

      taskForm.addEventListener("submit", (event) => {
        event.preventDefault();
        const newTask = {
          id: editingId ?? crypto.randomUUID(),
          title: titleInput.value.trim(),
          category: categoryInput.value,
          date: dateInput.value,
          progress: Math.min(Math.max(Number(progressInput.value) || 0, 0), 100),
        };

        if (editingId) {
          const index = tasks.findIndex((task) => task.id === editingId);
          tasks[index] = newTask;
        } else {
          tasks.push(newTask);
        }
        taskForm.reset();
        editingId = null;
        submitBtn.querySelector("span").textContent = "添加任务";
        submitBtn.classList.remove("from-neon", "to-accent");
        renderTasks();
        renderCalendar();
        updateChart();
      });

      taskForm.addEventListener("reset", () => {
        editingId = null;
        submitBtn.querySelector("span").textContent = "添加任务";
        submitBtn.classList.remove("from-neon", "to-accent");
      });

      prevMonthBtn.addEventListener("click", () => {
        currentMonth = new Date(currentMonth.getFullYear(), currentMonth.getMonth() - 1, 1);
        renderCalendar();
      });

      nextMonthBtn.addEventListener("click", () => {
        currentMonth = new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1);
        renderCalendar();
      });

      renderTasks();
      renderCalendar();
      updateChart();
    </script>
  </body>
</html>

浏览器直接打开plan.html

• 代码修改类

[任务类型]：请优化 {上下文：具体文件路径/代码片段}，实现 {预期目标}  

[当前问题]：{错误描述/性能瓶颈/逻辑漏洞}  

[具体要求]：  
1. 保持 {UI 交互/核心业务逻辑} 不变  
2. 使用 {技术方案} 改进（如 React 并发模式、Webpack 代码分割）  
3. 修复 {具体问题}（如内存泄漏、TS 类型错误）  

示例：请修改当前 React 项目的图片加载组件，优化首屏渲染性能。  
当前问题：图片未懒加载导致首屏加载时间超过 3s，Lighthouse 性能评分仅 42 分。  
要求：  
1. 保持图片展示与交互逻辑不变  
2. 使用 next/image 实现自动懒加载与响应式处理  
3. 添加骨架屏占位与错误重试机制  
4. 生成性能优化前后的 Lighthouse 对比报告

• 代码解释类

[任务类型]：请解析 {代码模块/设计模式} 的 {技术要点}  

[上下文信息]：{项目背景/技术栈/业务场景}  

[具体问题]：  
1. {语法糖/底层原理} 如何工作？  
2. {设计选择} 的优缺点与适用场景  
3. {潜在风险} 及优化方案 

示例：请解释 Vue 3 组合式 API 中 ref 与 reactive 的区别与应用场景。  
上下文：正在开发一个中大型后台管理系统，需选择状态管理方案。  
具体问题：  
1. ref 为什么需要 .value 解包？与 reactive 的响应式原理差异？  
2. 何时应该使用 ref 而非 reactive？请举例说明  
3. 组合式 API 中如何避免 ref 解包导致的代码冗余

• 流程自动化类

[任务类型]：请构建自动化工作流，实现 {业务目标}  

[执行流程]：  
1. 从 {数据源} 获取 {数据类型}（如 GitHub API 获取 PR 数据）  
2. 执行 {处理逻辑}（如数据清洗、格式转换）  
3. 将结果 {输出方式}（如保存至数据库、生成报表）  
4. 触发 {后续动作}（如通知推送、定时任务）  

[技术要求]：  
1. 使用 {工具/框架}（如 GitHub Actions、Python Airflow）  
2. 集成 {容错机制}（如重试策略、异常告警）  
3. 生成 {可观测性} 输出（如日志追踪、执行统计）

示例：请创建自动化部署流程，实现前端项目代码推送到 main 分支后自动发布到生产环境。  
执行流程：  
1. 监听 GitHub main 分支代码变更  
2. 使用 npm run build 生成生产包并进行代码压缩  
3. 通过 SFTP 上传至服务器 /var/www/html 目录  
4. 触发 Nginx 配置重载并记录部署日志  
技术要求：  
1. 使用 GitHub Actions 工作流  
2. 添加部署前代码 lint 检查与单元测试  
3. 失败时自动发送邮件通知并回滚至最近稳定版本

• 命令行辅助类

[任务类型]：请提供 {操作场景} 的 {操作系统} 命令方案  

[需求详情]：  
1. {具体操作}（如文件批量处理、环境配置）  
2. 包含 {参数/选项}（如 -r 递归、-v  verbose）  
3. 处理 {边界情况}（如空文件、权限问题） 

示例：请提供 Linux 系统下清理项目中未使用依赖包的命令方案。  
需求详情：  
1. 扫描 Node.js 项目中 package.json 与源码的依赖引用  
2. 列出所有已安装但未被引用的 npm 包  
3. 支持交互式选择删除或生成清理脚本  
4. 保留 devDependencies 中的测试依赖

提示词优化技巧（结构化总结）

• 代码修改类
• 代码解释类
• 流程自动化类
• 命令行辅助类

1. 上下文锚定

   • 明确项目技术栈（如 "React + TypeScript 项目"）、业务场景（如 "电商结算模块"）
   • 示例："在当前 Vue 3 管理系统中，实现商品库存预警功能"

2. 需求颗粒度控制

   • 将复杂任务拆解为可执行步骤（如 "1. 创建数据库模型 2. 开发 API 接口 3. 实现前端表格"）
   • 反例："做一个电商网站" → 优化："开发电商网站的商品搜索模块，包含分词匹配与筛选功能"

3. 技术约束显式化

   • 指定必须 / 禁止使用的技术（如 "使用 Webpack 5 而非 Vite"、"禁止修改现有路由结构"）
   • 示例："用原生 JavaScript 实现，不依赖任何框架"

4. 结果验收标准

   • 明确性能指标（如 "首屏加载 < 1.5s"）、兼容性要求（如 "支持 iOS 14+ 与 Chrome 80+"）
   • 示例："生成的代码需通过 ESLint 校验（配置文件见 .eslintrc.json）"

5. 示例引导策略

   • 提供目标代码片段或交互原型（如 "类似 axios 的请求拦截器写法"）
   • 格式：" 请按如下风格实现：\njs\n// 示例代码\nfunction request(url) { ... }\n"

格式说明

• 变量替换：{} 内为需自定义内容，实际使用时替换为具体描述
• 层级规范：使用 [任务类型] 作为一级标题，[具体要求] 作为二级内容
• 代码块示例：通过 markdown 与 包裹，确保语法高亮与格式保留

2.2、Chat三种模式

Composer 功能在 Cursor 较新的版本（约 0.46.8 之后）中已经被正式移除了

Composer 是 Cursor 早期版本中的一个核心AI功能，它的主要定位是代码生成。

• 工作方式：你通常在一个独立的输入框或面板中，用自然语言描述你想要的代码（例如：“写一个Python函数来计算斐波那契数列”），Composer 就会根据你的描述生成整段代码。

• 特点：它更侧重于从零开始“创作”新代码，而不是在现有代码的基础上进行问答或编辑。

Cursor 在最新版本（0.46.8 及以后）中移除了 Composer 和 Bug Finder 功能，主要是为了简化用户体验，并整合多个模式。

为什么移除了 Composer？

根据 Cursor 官方的解释，移除 Composer（以及 Bug Finder 功能）是为了：

• 简化用户体验：减少界面中不同输入框和模式的数量，降低用户的学习成本。

• 整合功能：将多个分散的功能整合到一个统一、更强大的界面中。

现在用什么来替代 Composer？

原先由 Composer 负责的代码生成任务，现在已经被完全整合到了统一的 Chat 模式 中。

在新的 Chat 界面里，你可以通过指令来实现类似甚至更强大的代码生成功能，主要替代方案是：

• .a （Agent 模式）：这是最强大、最接近 Composer 精神的模式。你给出一个高级任务（例如：“为我的博客网站创建一个联系表单”），AI 会像一个智能代理一样，自主分析你的项目文件，并生成、修改多个相关文件来完成请求。这是新版中完成代码生成工作的首选方式。

• .e （Edit 模式）：更侧重于对你已选中的代码块进行重写、重构或优化。

• 直接输入：你也可以直接在 Chat 中输入需求，AI 会根据上下文判断是生成新代码还是回答问题。

他们将 Chat 模式作为主要交互方式，结合了之前的 Composer 和 Command 模式的功能，使用户可以在一个统一的界面中进行代码生成、编辑和命令执行。此外，新的界面提供了 Agent、Ask 和 Edit 三种模式，以替代原来的 Composer 功能。

Chat 提供针对特定任务优化的不同模式：

• Agent代理模式（默认）: 允许Cursor学习和理解我们的项目代码，并且代表们可以直接进行项目代码更改！[识别项目结构]
• Ask对话模式：获取项目代码相关的解释和答案，但是不会直接修改项目代码！[识别项目结构]
• Manual手动模式（老版本）：需要我们执行项目上下文（修改范围，后续会详细讲解）重点编辑！[不识别项目结构]
• Plan模式（新版本）：执行前先生成详细方案的规划式开发模式，像 “带规划能力的项目经理”，先拆解任务、制定步骤，再按计划执行。

2.2.1、Agent模式

Agent 是 Cursor 中的默认且最自主的模式，旨在以最少的指导处理复杂的编码任务。它启用了所有[工具 ]，可以自主探索您的代码库、阅读文档、浏览 Web、编辑文件和运行终端命令以高效完成任务。

• Agent代理模式（默认）：全自动代码库操作与复杂任务执行
• 核心能力：
  • 深度分析项目结构与依赖关系
  • 自主执行多文件修改与跨模块重构
  • 维护长周期任务上下文
  • 独立探索您的代码库，识别相关文件，并进行必要的更改
  • 使用所有可用工具搜索、编辑、创建文件和运行终端命令
  • 将复杂任务分解为可管理的步骤并按顺序执行

生成和修改示例

1、新打开一个文件夹

2、Ctrl+L 开始Chat对话

3、对话用例

使用html,css,javascript来实现一个贪吃蛇页面！
要求：
  1. 要求有积分统计
  2. 页面要有多种背景可以切换
  3. 代码添加中文注释
  4. 不能使用var 只能使用let和const声明变量

4、生成代码

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>贪吃蛇小游戏</title>
  <style>
    /* 页面基础样式 */
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      font-family: "Segoe UI", "PingFang SC", sans-serif;
    }

    body {
      min-height: 100vh;
      display: flex;
      justify-content: center;
      align-items: center;
      transition: background 0.5s ease;
      background: linear-gradient(135deg, #141e30, #243b55);
    }

    .game-wrapper {
      width: 420px;
      padding: 24px;
      border-radius: 18px;
      background: rgba(0, 0, 0, 0.55);
      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.4);
      color: #fff;
    }

    h1 {
      text-align: center;
      margin-bottom: 16px;
      font-size: 28px;
      letter-spacing: 2px;
    }

    .score-board {
      display: flex;
      justify-content: space-between;
      gap: 8px;
      margin-bottom: 12px;
      padding: 12px;
      border-radius: 12px;
      background: rgba(255, 255, 255, 0.08);
      font-weight: bold;
      flex-wrap: wrap;
    }

    .score-board span.value {
      margin-left: 4px;
      color: #38bdf8;
    }

    canvas {
      display: block;
      margin: 12px auto 18px;
      background: rgba(12, 12, 12, 0.85);
      border-radius: 12px;
      box-shadow: inset 0 0 12px rgba(0, 0, 0, 0.6);
    }

    .controls {
      display: flex;
      gap: 12px;
      align-items: center;
      justify-content: space-between;
      flex-wrap: wrap;
    }

    select,
    button {
      flex: 1;
      padding: 10px 12px;
      border: none;
      border-radius: 10px;
      font-size: 14px;
      cursor: pointer;
      transition: transform 0.2s ease, opacity 0.3s ease;
    }

    select {
      background: rgba(255, 255, 255, 0.9);
      color: #111;
    }

    button {
      background: #22c55e;
      color: #fff;
      font-weight: bold;
    }

    button:active {
      transform: scale(0.97);
    }
  </style>
</head>
<body>
  <div class="game-wrapper">
    <h1>贪吃蛇</h1>
    <div class="score-board">
      <div>当前积分：<span id="score" class="value">0</span></div>
      <div>最高积分：<span id="highScore" class="value">0</span></div>
      <div>剩余时间：<span id="timer" class="value">60s</span></div>
    </div>
    <canvas id="gameCanvas" width="380" height="380"></canvas>
    <div class="controls">
      <select id="bgSwitcher">
        <option value="0">城市霓虹</option>
        <option value="1">森林晨光</option>
        <option value="2">沙漠暖阳</option>
        <option value="3">极光星空</option>
      </select>
      <button id="toggleBtn">开始游戏</button>
    </div>
    <p style="margin-top:12px;font-size:13px;color:#d1d5db;text-align:center;">
      使用方向键控制蛇移动，空格暂停/继续
    </p>
  </div>

  <script>
    // 画布与上下文
    const canvas = document.getElementById("gameCanvas");
    const ctx = canvas.getContext("2d");

    // 控制元素
    const scoreEl = document.getElementById("score");
    const highScoreEl = document.getElementById("highScore");
    const bgSwitcher = document.getElementById("bgSwitcher");
    const toggleBtn = document.getElementById("toggleBtn");
    const timerEl = document.getElementById("timer");

    // 背景主题配置
    const backgrounds = [
      "linear-gradient(135deg, #0f2027, #203a43, #2c5364)",
      "linear-gradient(135deg, #1c9200, #6ddc4b)",
      "linear-gradient(135deg, #f7971e, #ffd200)",
      "radial-gradient(circle at top, #4e54c8, #1c1c44)"
    ];

    // 游戏基础配置
    const gridSize = 20; // 每一格像素大小
    const tileCount = canvas.width / gridSize; // 网格数量
    const initialSnake = [{ x: 9, y: 9 }];

    let snake = [...initialSnake];
    let direction = { x: 1, y: 0 };
    let nextDirection = { x: 1, y: 0 };
    let food = { x: 5, y: 5 };
    let score = 0;
    let highScore = 0;
    let gameInterval = null;
    let countdownInterval = null;
    let isRunning = false;
    let countdown = 60;

    // 工具函数：生成随机食物
    const spawnFood = () => {
      // 避免食物刷在蛇身上
      while (true) {
        const newFood = {
          x: Math.floor(Math.random() * tileCount),
          y: Math.floor(Math.random() * tileCount)
        };
        const conflict = snake.some(segment => segment.x === newFood.x && segment.y === newFood.y);
        if (!conflict) {
          food = newFood;
          return;
        }
      }
    };

    // 更新积分显示
    const updateScoreBoard = () => {
      scoreEl.textContent = score;
      highScoreEl.textContent = highScore;
    };

    // 更新倒计时显示
    const updateTimerDisplay = () => {
      timerEl.textContent = `${countdown}s`;
    };

    // 启动倒计时
    const startCountdown = () => {
      clearInterval(countdownInterval);
      countdownInterval = setInterval(() => {
        countdown -= 1;
        updateTimerDisplay();
        if (countdown <= 0) {
          endGame(true);
        }
      }, 1000);
    };

    // 重置游戏
    const resetGame = () => {
      snake = [...initialSnake];
      direction = { x: 1, y: 0 };
      nextDirection = { x: 1, y: 0 };
      score = 0;
      countdown = 60;
      spawnFood();
      updateScoreBoard();
      updateTimerDisplay();
    };

    // 游戏循环
    const gameTick = () => {
      // 避免同帧内多次改方向导致反向
      direction = { ...nextDirection };

      const head = { x: snake[0].x + direction.x, y: snake[0].y + direction.y };

      // 边界碰撞判定
      if (head.x < 0 || head.x >= tileCount || head.y < 0 || head.y >= tileCount) {
        endGame();
        return;
      }

      // 身体碰撞判定
      if (snake.some(segment => segment.x === head.x && segment.y === head.y)) {
        endGame();
        return;
      }

      // 将新头插入蛇身数组
      snake.unshift(head);

      // 判断是否吃到食物
      if (head.x === food.x && head.y === food.y) {
        score += 10;
        if (score > highScore) {
          highScore = score;
        }
        updateScoreBoard();
        spawnFood();
      } else {
        snake.pop();
      }

      drawScene();
    };

    // 绘制画面
    const drawScene = () => {
      // 清空画布
      ctx.fillStyle = "#060606";
      ctx.fillRect(0, 0, canvas.width, canvas.height);

      // 绘制食物
      ctx.fillStyle = "#f97316";
      ctx.fillRect(food.x * gridSize, food.y * gridSize, gridSize, gridSize);

      // 绘制蛇身
      ctx.fillStyle = "#22d3ee";
      snake.forEach((segment, index) => {
        ctx.fillRect(segment.x * gridSize, segment.y * gridSize, gridSize - 1, gridSize - 1);
        if (index === 0) {
          ctx.fillStyle = "#0ea5e9";
        }
      });
    };

    // 游戏结束处理
    const endGame = (timeUp = false) => {
      clearInterval(gameInterval);
      clearInterval(countdownInterval);
      isRunning = false;
      toggleBtn.textContent = "重新开始";
      const message = timeUp ? "时间到，挑战结束！点击按钮再来一次！" : "游戏结束，点击按钮再来一次！";
      alert(message);
    };

    // 启动或暂停游戏
    const toggleGame = () => {
      if (isRunning) {
        clearInterval(gameInterval);
        clearInterval(countdownInterval);
        isRunning = false;
        toggleBtn.textContent = "继续游戏";
        return;
      }
      if (snake.length === 1 && score === 0) {
        spawnFood();
      }
      if (!isRunning) {
        if (toggleBtn.textContent === "重新开始") {
          resetGame();
        }
        toggleBtn.textContent = "暂停游戏";
        isRunning = true;
        gameInterval = setInterval(gameTick, 120);
        startCountdown();
      }
    };

    // 监听键盘事件
    document.addEventListener("keydown", event => {
      switch (event.key) {
        case "ArrowUp":
          if (direction.y === 0) {
            nextDirection = { x: 0, y: -1 };
          }
          break;
        case "ArrowDown":
          if (direction.y === 0) {
            nextDirection = { x: 0, y: 1 };
          }
          break;
        case "ArrowLeft":
          if (direction.x === 0) {
            nextDirection = { x: -1, y: 0 };
          }
          break;
        case "ArrowRight":
          if (direction.x === 0) {
            nextDirection = { x: 1, y: 0 };
          }
          break;
        case " ":
          toggleGame();
          break;
        default:
          break;
      }
    });

    // 背景切换事件
    bgSwitcher.addEventListener("change", event => {
      const index = Number(event.target.value);
      document.body.style.background = backgrounds[index];
    });

    // 按钮绑定
    toggleBtn.addEventListener("click", () => {
      if (!isRunning && toggleBtn.textContent === "开始游戏") {
        resetGame();
      }
      toggleGame();
    });

    // 初始设置
    document.body.style.background = backgrounds[0];
    resetGame();
    drawScene();
  </script>
</body>
</html>

5、运行代码对话

6、调整优化代码对话，如：在页面中添加倒计时功能，每次60秒！

Agent的配置选项：

• Model（选择模型 ）：为代理模式预先选择大模型
• Edit Keybindings（编辑快捷键）： 为agent模式设置快速开启快捷键（默认 ctrl + i）
• Auto-run ( 自动运行 ) ：当你让 Agent 修改代码后，自动执行相关命令（如编译、测试、运行），验证修改的正确性。
• Auto-fix errors ( 自动修复 ) ：当自动运行过程中出现错误（如编译失败、测试报错），Agent 会尝试分析错误信息并自动修复。

错误调试和修改示例：

1、准备错误信息类

public class ArrayDemo {
    public static void main(String[] args) {
        // 创建一个整数数组
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        
        // 使用for循环输出数组内容
        System.out.println("数组内容如下：");
        for (int i = 0; i < numbers.length; i++) {
            // 直接使用当前下标即可避免越界
            System.out.println("第 " + (i + 1) + " 个元素是: " + numbers[i]);
        }
        
        // 使用增强型for循环输出数组内容
        System.out.println("\n使用增强型for循环输出：");
        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }
}

2、运行报错

3、对话解决错误信息

2.2.2、Ask模式

Ask 是 Chat 的 “只读” 模式，用于提出问题、探索和了解代码库。它是 Cursor 中的一种内置对话模式！

对比：Ask 是其他默认模式（Agent 和 Manual）所独有的，因为它默认不应用任何建议的更改 - 这使它成为一种 “只读” 模式，具有读取文件和其他上下文的完整能力，但不能自行进行任何更改。这对于了解我们可能不想更改的代码库或在实施之前使用 AI 规划解决方案非常有用！

示例：

Ask的配置选项：

• Model （模型) : 预先选择应作为 Ask （Ask ） 的默认模型
• Keybinding : 设置键绑定以切换到 Ask 模式
• 搜索代码库 : 允许 Cursor 搜索它自己的上下文，而不是当你希望 AI 看到文件时，你必须手动 @ 文件作为上下文

2.2.3、Plan模式（新版本）

@plan 是一个基于规划-执行的 AI 代理工作流。它的核心理念是：

对于复杂任务，不要直接动手编码，而是先制定一个详细的、可审查、可修改的步骤计划，然后再自动执行这个计划。

这模仿了优秀工程师的思考方式：先设计，再编码。

步骤 1：提出需求

• 在 @plan 指令后，描述你的复杂任务。

• 示例： @plan 为项目添加用户登录功能，包括User模型、auth路由和JWT认证。

步骤 2：生成计划

• Cursor 的 AI 会分析你的代码库结构，然后生成一个非常详细的、分步骤的文本计划。

• 计划示例可能如下：

  计划：添加用户登录功能

  1. 在 models/ 目录创建 user.py 文件，定义 User 模型，包含 id, username, email, hashed_password 字段。

  2. 在 auth.py 中创建以下函数：

     • hash_password(password: str) -> str

     • verify_password(password: str, hashed: str) -> bool

     • create_jwt_token(user_id: int) -> str

     • verify_jwt_token(token: str) -> dict

  3. 在 routes/ 目录创建 auth_routes.py，实现 /login (POST) 和 /register (POST) 端点。

  4. 更新 main.py，将 auth_routes 蓝图注册到应用。

  5. 在项目根目录创建 .env.example 文件，说明需要设置 JWT_SECRET_KEY 环境变量。

步骤 3：审查与编辑（最关键的一步！）

• 你可以仔细阅读这个计划。如果发现任何问题，或者想调整方案，你可以直接在这个计划文本上进行编辑。

• 比如，你觉得步骤2和3应该合并，或者想增加一个“密码重置”功能，直接像编辑普通文本一样修改计划即可。这给了你巨大的控制权。

步骤 4：执行计划

• 当你对计划满意后，将光标放在计划文本的任何位置，按下 Ctrl + Enter。

• Cursor 会启动一个 Agent，开始自动地、一步一步地执行计划中的每一项。你会看到它依次创建文件、编写代码、修改现有代码，整个过程无需你干预。

---

@plan 的最佳使用场景

• 大型重构：@plan 将整个项目从 JavaScript 迁移到 TypeScript。

• 添加复杂功能：@plan 实现一个购物车系统，包括模型、API 和前端组件。

• 代码拆分与架构调整：@plan 将这个庞大的 utils.py 拆分为 config、database 和 helpers 三个模块。

• 系统性地修复问题：@plan 修复项目中所有关于日期时区处理的错误。

2.2.4、Manual模式（老版本）

与 Ask 模式不同，它不探索代码库或运行终端命令;它完全取决于您的具体说明和您提供的上下文（例如，通过 @文件名），AI 生成修改建议后，还要用户手动点击 “应用” 才会改动代码，且通常是单文件 / 局部代码调整。

示例用例：

在 @script.js @index.html 中，给所有代码添加注释和解释！
 

Cursor 中 Chat 模式将 Manual 替换为 Plan 后，二者核心差异体现在核心定位、适用场景、工具权限等多个维度，Manual 是 “精准执行者”，侧重按明确指令完成简单编辑；Plan 是 “规划执行者”，侧重先制定方案再落地复杂任务，以下是具体区别：

对比维度	Manual 模式	Plan 模式
核心定位	以用户为主导的精准代码编辑模式，像 “听话的执行工匠”，仅严格按用户指令做事，不做任何自主规划与探索。	执行前先生成详细方案的规划式开发模式，像 “带规划能力的项目经理”，先拆解任务、制定步骤，再按计划执行。
适用场景	适合用户明确知道修改内容和位置的场景，比如单文件 / 多文件的特定函数修改、添加固定格式注释、简单变量替换等小型局部调整。	适合复杂开发任务，比如从零搭建新项目、开发完整用户认证模块、重构大型代码库、实现多文件协同的复杂业务逻辑等。
工具权限	功能受限，仅启用文件编辑工具，搜索、终端等工具均被禁用，且无法自主调用代码库检索、网络搜索等功能，需用户手动通过 @指定文件才能操作。	启用所有工具，可自主检索代码库、调用搜索工具收集上下文，也能配合终端等工具完成复杂操作，工具调用自主性极强。
工作流程	用户通过 @指定文件 + 下达明确修改指令→工具执行对应编辑→修改完成即任务结束，无中间规划环节，用户可直接审查修改结果。	用户提出需求→Agent 检索代码库 + 提出澄清问题→生成详细实现计划→用户审阅并编辑计划→确认后 Agent 按计划执行→执行中可动态调整。
可控与透明性	可控性体现在指令精准度上，用户需提供清晰指令才能保证结果准确，但无中间环节，修改过程直接落地，无需额外确认。	透明性和可控性更强，生成的计划以 plan.md 文件形式呈现，用户可查看步骤拆分、文件修改清单，还能直接编辑计划调整方向，避免 AI 盲目操作。
额外特性	无额外文件产出，修改直接作用于指定文件，适合快速完成简单需求，不产生冗余内容。	会生成临时计划文件，可保存到工作区的.cursor/plans/ 目录，便于后续查阅、团队共享和项目文档化，适配团队协作场景。

2.3、Chat模式的其他细节

2.3.1、代码编辑选项

当 Chat 建议更改代码时：

1、Review：在差异视图中查看建议的更改

2、Apply: 在“ask / Manual ”模式下，使用“应用”按钮显式应用更改

3、Undo/Keep（新版） 或者 Accept/Reject(老版，接受/拒绝) ：进行更改后，决定是保留还是放弃更改(agent模式下)

2.3.2、Checkpoints 数据还原

有时，可能希望恢复到代码库的先前状态。Cursor 通过在发出的每个请求以及每次 AI 更改的代码库时自动创建代码库的检查点（Checkpoints）来帮助您解决这个问题。

要恢复到以前的状态，您可以：单击上一个请求的输入框中显示的 Restore Checkpoint 按钮，如下所示

注意：是回复到本次对话之前的状态！！不是本次对话产生的状态！！

2.3.3、历史和新建会话

聊天历史记录已移至命令面板。可以通过 Chat 中的 “Show history” 按钮以及运行命令面板中的 “Show Chat History” 命令来访问它。

开启新任务、避免对话混乱、保留特定记录或解决误操作时，需在 Cursor 的 Chat 新建聊天框。

2.3.4、Chat相关的配置说明

• Default new chat mode：设置新聊天默认模式，选 “Agent” 则新聊天默认用智能代理交互 ，决定初始聊天交互载体。

• Chat text size：调整 AI 聊天消息文字大小，“Default” 是默认尺寸，可按需改显示效果，让阅读更舒适。

• Auto - refresh chats：勾选后，聊天面板闲置再打开时自动新建聊天，保持交互新鲜度，避免旧聊天堆积干扰。

• Auto - scroll to bottom：新消息生成时自动滚动到聊天面板底部，不用手动翻，方便实时看最新内容。

• Auto - apply to files outside context in Manual mode：手动模式下，允许聊天对当前上下文外文件自动应用更改，拓展操作范围，处理跨文件任务更便捷。

• Include project structure（BETA） ：勾选后，给模型提供简化目录树，辅助理解代码库布局，让 AI 更贴合项目结构做响应，尚处测试阶段。

• Full folder contents：启用后，展示完整文件夹内容而非结构大纲，需详细文件内容时开启，便于深度查看。

• Enable auto - run mode：允许 Agent 不经确认自动运行工具（如执行命令、写文件），效率高但有风险，需信任场景用，要留意误操作。

• Command allowlist：仅指定命令能自动执行，精准管控，保障安全又保留特定自动操作。

• Command denylist：列入的命令永不自动执行，规避危险命令，加固安全防线。

• Delete file protection：启用后阻止 Agent 自动删文件，防误删关键文件，保护数据安全。

• MCP tools protection：开启则 Agent 不能自动运行 MCP 工具，避免工具误操作影响系统。

• Dot files protection：已勾选，阻止 Agent 自动改点文件（如.gitignore ），保护版本控制等配置文件。

• Outside workspace protection：勾选后，Agent 无法自动创建 / 修改工作区外文件，防止影响外部系统，保障工作区独立性。

• Dialog ‘Don’t ask again’ preferences：管理曾选 “不再询问” 的对话框，方便回顾或重置交互确认逻辑。

• Collapse input box pills in pane or editor：勾选则折叠聊天面板 / 编辑器输入框里的标识，节省空间，让界面更简洁。

• Iterate on lints：启用后，Agent 模式聊天自动迭代修复代码检查（linter ）错误，助力自动代码优化。

• Hierarchical Cursor Ignore：启用后，cursorignore 文件规则作用于所有子目录，改配置需重启 Cursor，统一忽略规则时用。

• Auto - accept diffs：启用后，合成器里的差异（diffs ）在不在工作树中就会被接受，自动处理版本差异，简化流程。

• Custom modes（BETA） ：允许创建自定义模式，可按需定制交互逻辑，尚在测试，探索个性化玩法。

• Play sound on finish（BETA） ：聊天响应完成时播放声音提醒，不用一直盯着，及时知晓结果，测试功能。

• Auto Group Changes（BETA） ：自动分组聊天会话中与大语言模型（LLM ）交互产生的更改，方便集中 review，测试阶段功能。

• Web Search Tool（BETA） ：已勾选，允许 Agent/ask 模式聊天联网搜索信息，补充知识，让回答更全面，测试功能

3、Ctrl+K: 内联智能修改

允许用户使用自然语言指令来编写和更新代码。开发者只需通过简单的文本描述，如 “实现一个冒泡排序函数”“添加一个用户登录接口” 等，Cursor 就会根据这些自然语言描述生成相应的函数、类或完整模块等代码，将自然语言转化为可运行的代码，大大提高了开发效率，尤其适合快速实现一些功能需求或对代码进行快速修改。

内联编辑 （Cmd/Ctrl+K） 直接在编辑器窗口中生成新代码或编辑现有代码。

3.1、触发修改提示框

在 Cursor 中，我们将按 Ctrl/Cmd K 时出现的栏称为“Prompt Bar”。它的工作原理类似于用于聊天的 AI 输入框，可以在其中正常键入，或使用 @引用其他上下文

Ctrl+K的模式说明：

• 内联生成：如果在按 Ctrl/Cmd K 时未选择任何代码，Cursor 将根据您在提示栏中键入的提示生成新代码。
• 内联编辑：对于就地编辑，只需选择要编辑的代码，然后在提示栏中键入即可。

3.2 Cmd + K 体验

• 内联生成

1. 打开main.js，光标放文件末尾（无选中代码）
2. 按Ctrl+K，输入提示：“生成一个带点击动画的按钮组件，用 JavaScript 实现，点击后控制台打印次数”
3. 实现效果

• 内联编辑

1. 继续打开刚刚的main.js

2. 选中任意方法，按Ctrl+K，输入提示：“方法添加注释和每行代码添加注释说明”

3.3、Terminal Cmd + K 体验

在 Cursor 终端中使用 Cmd K 通过提示栏界面生成和运行命令, 在内置的 Cursor 终端中，您可以按 Ctrl/⌘+K 打开终端底部的提示栏。此提示栏允许您在终端中描述所需的作，终端 Cmd K 将生成一个命令。您可以通过按 esc 接受命令，也可以立即使用 Ctrl/⌘ + Enter 运行命令。

二、CurSor七大核心能力深度详解

给 AI 设定「固定规则」，让其在所有项目中遵循统一的编码规范、技术栈偏好、输出格式，避免重复沟通，生成的代码直接符合你的需求。

「代码库索引 + 外部文档知识库」解决 “AI 不懂你的项目 / 业务”；

「AI 审查重构 + 自定义 Rules」解决 “代码质量低、不规范”；

「隐私模式」解决 “敏感代码不敢用 AI”；

「模型选择」解决 “不同场景适配不同 AI 能力”；

「MCP 服务器」解决 “AI

Cursor 七大核心能力深度详解（含实操指南）

Cursor 作为 AI 驱动的代码编辑器，核心优势是将「AI 能力与编码场景深度融合」，以下 7 大核心能力从实操配置、使用场景、进阶技巧三方面展开，帮你彻底发挥 Cursor 的效率优势：

1、代码库索引（Codebase Indexing）：让 AI 读懂你的整个项目

1. 核心作用

解决「AI 只懂单文件，不懂项目全局」的痛点 —— 通过索引整个项目的文件结构、代码依赖、变量 / 函数定义，让 AI 生成代码时能精准适配项目规范、复用已有逻辑，避免 “闭门造车”。

2. 实操配置

• 启用索引：打开 Cursor → 设置（Ctrl+,）→ 功能（Features）→ 代码库索引（Codebase Indexing）→ 开启「启用代码库索引」；
• 自定义索引范围：
  • 自动索引：开启后 Cursor 会自动扫描当前打开的项目根目录，实时同步文件新增 / 修改；
  • 忽略文件：创建 .cursorignore 文件（放在项目根目录），写入无需索引的文件 / 目录（语法同 .gitignore），示例：

    # .cursorignore 示例
    dist/          # 忽略打包目录
    node_modules/  # 忽略依赖目录
    *.log          # 忽略日志文件
    .env*          # 忽略环境变量文件
    

• 手动刷新索引：项目文件批量修改后，可点击设置中「刷新索引」按钮，确保 AI 获取最新项目上下文。

3. 核心使用场景

• 跨文件代码生成：比如在 user.vue 中输入提示词 “基于项目 api/user.js 中的 getUser 接口，写一个用户信息展示组件”，AI 会通过索引直接复用接口定义，生成适配的组件代码；
• 全局逻辑查询：在 AI 侧边栏输入 “项目中哪里用到了 formatDate 函数？帮我修改它的时间格式”，AI 会通过索引定位所有引用位置，并生成批量修改方案；
• 新项目快速上手：打开别人的项目后，无需逐文件阅读，输入 “帮我总结这个项目的目录结构和核心功能”，AI 基于索引快速生成项目说明。

4. 进阶技巧

• 索引大项目时，优先忽略 dist、node_modules 等无业务逻辑的目录，提升索引速度；
• 索引完成后，使用 @codebase 关键词触发项目级查询（如 “@codebase 帮我找所有未使用的函数”）。

2、AI 审查和代码重构（AI Review & Refactoring）：让代码更优雅、更高效

1. 核心作用

相当于「内置资深架构师」—— 自动审查代码中的问题（语法错误、性能瓶颈、安全漏洞、不规范写法），并提供重构方案，既解决 Bug，又优化代码质量。

2. 实操配置

• 启用 AI 审查：设置 → 功能 → AI 审查（AI Review）→ 开启「自动审查打开的文件」（可选，默认关闭，手动触发更灵活）；
• 核心触发方式：
  • 方式 1：选中目标代码块 → 右键 → 选择「Cursor: 审查代码」（或快捷键 Ctrl+Shift+R）；
  • 方式 2：AI 侧边栏输入提示词（如 “审查这段代码的性能问题并重构”），粘贴代码后发送；
  • 方式 3：打开文件后，输入 // 帮我审查这个文件并优化，按 Alt+\ 触发 AI 全文件审查。

3. 核心使用场景

• 语法 / 逻辑 Bug 修复：选中报错代码（如嵌套过深的 if-else、内存泄漏风险的代码），AI 会定位问题并生成修复后的代码，同时解释原因；
• 代码简化：选中冗长代码（如重复的条件判断、复杂的循环），AI 会用设计模式（如策略模式、迭代器模式）或简洁语法重构，降低复杂度；
• 性能优化：输入 “优化这段数据库查询代码，提升执行速度”，AI 会优化 SQL 语句、添加缓存逻辑、减少循环次数等；
• 规范对齐：选中代码后输入 “按照 Airbnb 规范重构这段 JavaScript 代码”，AI 自动调整命名、缩进、注释等细节。

4. 进阶技巧

• 重构时明确目标（如 “重构为 Vue 3 组合式 API”“重构为异步代码”“提升代码可读性”），AI 生成的方案更精准；
• 审查大型文件时，分段选中代码（如按函数 / 组件拆分），避免 AI 处理过载；
• 重构后使用「AI 审查」二次验证，确保没有引入新问题。

3、隐私模式（Privacy Mode）：保护敏感代码不泄露

1. 核心作用

解决「企业 / 涉密项目不敢用 AI 工具」的痛点 —— 开启后所有 AI 交互（代码生成、提问、审查）都在本地完成，不会将代码上传到云端模型，数据 100% 安全。

2. 实操配置

• 开启隐私模式：
  • 方式 1：点击 Cursor 右上角「隐私模式」图标（盾牌图标），切换为开启状态（图标变亮）；
  • 方式 2：设置 → 隐私（Privacy）→ 开启「隐私模式」，并选择本地模型（需提前下载，如 Llama 3、Mistral 等开源模型）；
• 模型下载：隐私模式下，需手动下载本地模型（设置 → 模型 → 本地模型 → 选择模型版本下载，如 Llama 3 70B），首次下载需消耗一定网络流量，后续使用无需联网。

3. 核心使用场景

• 开发企业私有项目（如核心业务代码、支付逻辑、涉密算法）；
• 处理敏感数据（如用户隐私信息、财务数据、未公开的技术方案）；
• 禁止代码外传的场景（如保密协议约束、内部项目开发）。

4. 注意事项

• 隐私模式依赖本地模型，生成速度、代码质量略低于云端模型（如 GPT-4o、Claude 3.5）；
• 本地模型需要占用一定硬盘空间（如 Llama 3 70B 约占 40GB 存储空间），需确保硬盘有足够容量；
• 开启隐私模式后，部分依赖云端的功能（如 MCP 服务器、外部知识库）可能受限。

4、模型选择（Model Selection）：按需匹配不同开发场景

1. 核心作用

Cursor 内置多种 AI 模型，可根据「开发场景、需求复杂度、成本预算」选择合适的模型，平衡效率和成本。

2. 实操配置

• 模型切换入口：
  • 方式 1：编辑器右下角点击模型名称（如 “GPT-4o”），弹出模型列表选择；
  • 方式 2：设置 → 模型（Models）→ 选择默认模型，同时可配置每个模型的调用参数（如温度值、最大响应长度）；
• 内置模型及特点：

模型类型	代表模型	优势	适用场景	免费额度
云端大模型	GPT-4o	代码质量高、理解能力强	复杂项目开发、核心逻辑编写、重构	500 次调用
云端大模型	Claude 3.5 Sonnet	长文本处理强、安全合规	大型文件分析、文档生成、合规审查	500 次调用
云端轻量模型	GPT-3.5 Turbo	速度快、成本低	简单代码补全、语法查询、小功能开发	无上限
本地开源模型	Llama 3 70B	隐私安全、无需联网	涉密项目、本地开发	无上限（需下载）
本地开源模型	Mistral 8x7B	轻量化、速度快	简单代码补全、本地快速开发	无上限（需下载）

3. 模型选择技巧

• 复杂场景（如框架迁移、架构设计、性能优化）选 GPT-4o 或 Claude 3.5，生成的代码质量更高；
• 简单场景（如代码补全、语法查询、小功能编写）选 GPT-3.5 Turbo，速度更快且不消耗高级模型额度；
• 涉密场景选本地模型（Llama 3、Mistral），兼顾隐私和 AI 辅助；
• 长文本处理（如分析 1000 行以上的代码文件）选 Claude 3.5 Sonnet，支持更长的上下文窗口。

5、自定义 Rules（Custom Rules）：打造专属 AI 编程助手

1. 核心作用

给 AI 设定「固定规则」，让其在所有项目中遵循统一的编码规范、技术栈偏好、输出格式，避免重复沟通，生成的代码直接符合你的需求。

2. 实操配置

• 配置入口：设置 → 通用（General）→ Rules for AI → 点击「编辑规则」，输入自定义规则（支持多行文本）；
• 规则生效范围：全局生效（所有项目、所有 AI 交互都遵循该规则），如需项目级规则，可在项目根目录创建 .cursorrules 文件（语法同全局规则）。

3. 核心规则示例（直接复制使用）

示例 1：Vue 3 开发规范

# 角色
你是一名精通 Vue 3 的前端工程师，严格遵循 Vue 最佳实践。

# 编码规则
1. 必须使用 Vue 3 组合式 API（setup 语法糖），禁止使用选项式 API；
2. 组件命名使用 PascalCase， props 命名使用 camelCase，事件命名使用 kebab-case；
3. 优先使用 Pinia 进行状态管理，禁止使用 Vuex；
4. 代码中必须添加关键逻辑注释，组件需添加 props 类型校验；
5. 样式使用 scoped 作用域，避免全局污染；
6. 优先使用 TypeScript 定义类型，避免 any 类型。

示例 2：Python 后端开发规范

# 编码规则
1. 命名规范：函数/变量使用 snake_case，类使用 PascalCase，常量使用 UPPER_SNAKE_CASE；
2. 代码缩进使用 4 个空格，禁止使用制表符；
3. 函数必须添加 docstring 注释（描述功能、参数、返回值）；
4. 优先使用内置库，如需第三方库，优先选择 requests、pandas 等主流库；
5. 数据库操作必须添加异常处理，避免 SQL 注入风险；
6. 输出日志使用 logging 模块，禁止使用 print。

4. 进阶技巧

• 规则中明确「禁止行为」和「优先行为」（如 “禁止使用 var 关键字，优先使用 let/const”）；
• 结合项目特点添加「工具偏好」（如 “前端请求优先使用 Axios，后端数据库优先使用 SQLAlchemy”）；
• 规则过多时，按 “角色→编码规范→工具偏好→输出格式” 分类，让 AI 更容易理解。

6、外部文档知识库（External Document Knowledge Base）：让 AI 参考你的专属文档

1. 核心作用

相当于给 AI 「喂专属教材」—— 上传外部文档（PDF、Markdown、Word 等），AI 会解析文档内容并建立知识库，后续提问时直接参考文档生成答案，解决 “AI 不懂你的业务逻辑、内部规范” 的问题。

2. 实操配置

• 上传文档：
  • 方式 1：AI 侧边栏 → 点击「添加知识库」（Add Knowledge）→ 选择本地文档（支持批量上传）；
  • 方式 2：拖拽文档到 AI 侧边栏，自动上传并解析；
• 文档支持格式：Markdown（.md）、PDF（.pdf）、Word（.docx）、纯文本（.txt），不支持图片中的文字（需提前 OCR 识别）；
• 知识库管理：上传后可在「知识库」标签页查看文档列表，支持删除、重命名、搜索文档内容。

3. 核心使用场景

• 业务逻辑开发：上传公司内部的「业务需求文档」「接口规范文档」，输入 “根据上传的接口规范，写一个调用用户登录接口的代码”，AI 参考文档生成符合规范的代码；
• 技术文档查询：上传框架官方文档（如 Django 中文文档），输入 “根据文档，如何实现 Django 的权限控制？”，AI 提取文档关键信息并给出答案；
• 考试 / 学习辅助：上传教材、笔记，输入 “根据上传的文档，总结 Python 装饰器的核心用法”，AI 生成知识点总结；
• 内部规范适配：上传公司「编码规范文档」「数据库设计文档」，AI 生成代码时自动遵循文档中的规则。

4. 进阶技巧

• 上传大文档时，优先拆分章节（如将 1000 页的 PDF 拆分为多个章节 PDF），提升 AI 检索速度；
• 提问时明确 “参考某份文档”（如 “参考《接口规范.md》，写一个获取用户信息的 API 代码”）；
• 文档更新后，重新上传并覆盖旧文档，确保 AI 使用最新内容。

7、MCP 服务器配置（MCP Server Configuration）：让 AI 对接你的本地工具 / 数据源

1. 核心作用

MCP（Model Context Protocol）是 Anthropic 推出的「AI 与外部系统对接的通用协议」—— 通过配置 MCP 服务器，让 Cursor 的 AI 直接调用本地工具（如终端、编译器）、访问本地数据源（如数据库、文件系统），实现 “AI 自动执行本地操作” 的闭环。

2. 核心概念

• MCP Server：本地运行的轻量服务，封装工具 / 数据源的能力，对外暴露统一接口（遵循 MCP 协议）；
• 三大核心能力：
  • Resources（资源）：读取本地文件、数据库数据等静态资源；
  • Tools（工具）：调用本地终端命令、编译器、自定义脚本等；
  • Prompts（提示词）：提供预设的提示词模板，优化 AI 交互效果；
• 官方 MCP 仓库：https://smithery.ai/（提供现成的 MCP Server 示例，如文件读取、图片生成、数据库访问等）。

3. 实操配置（以 “本地数据库访问” 为例）

步骤 1：下载现成的 MCP Server

• 克隆官方示例仓库：git clone https://github.com/anthropics/smithery.git；
• 进入数据库访问 Server 目录：cd smithery/examples/sqlite-server；
• 安装依赖：pip install -r requirements.txt。

步骤 2：配置 MCP Server

• 编辑 config.json，设置本地 SQLite 数据库路径：

  {
    "database_path": "./data/user.db",
    "allowed_tables": ["User", "Order"]  // 允许访问的表
  }
  

步骤 3：启动 MCP Server

• 运行命令：python server.py，默认端口 8080，启动成功后显示 “MCP Server running on http://localhost:8080”。

步骤 4：Cursor 连接 MCP Server

• 打开 Cursor → 设置 → MCP Servers → 点击「添加服务器」；
• 输入服务器名称（如 “本地 SQLite 服务器”）和地址（http://localhost:8080），点击「测试连接」，连接成功后保存。

步骤 5：使用 MCP Server 操作数据库

• AI 侧边栏输入 “查询 User 表中 25 岁以上的用户”，AI 会通过 MCP Server 访问本地数据库，返回查询结果并生成对应的 SQL 语句。

4. 核心使用场景

• 本地工具调用：配置终端 MCP Server，输入 “帮我运行当前项目的测试用例”，AI 调用本地终端执行 pytest 命令并返回结果；
• 私有数据源访问：配置企业内部数据库（MySQL、PostgreSQL）的 MCP Server，AI 直接查询数据并生成分析报告；
• 自定义工具集成：开发自己的 MCP Server（如调用本地打印机、控制硬件设备），让 AI 成为 “本地工具控制器”。

5. 注意事项

• MCP Server 需运行在本地，Cursor 仅通过 HTTP 接口通信，数据不经过云端，安全可控；
• 配置外部数据库时，避免使用 root 账号，限制数据库访问权限（如仅允许查询，禁止修改）；
• 自定义 MCP Server 时，需遵循 MCP 协议规范（参考官方文档：https://docs.smithery.ai/）。

核心总结

Cursor 的 7 大核心能力本质是「围绕 “AI 辅助编码” 的全场景解决方案」：

• 「代码库索引 + 外部文档知识库」解决 “AI 不懂你的项目 / 业务”；
• 「AI 审查重构 + 自定义 Rules」解决 “代码质量低、不规范”；
• 「隐私模式」解决 “敏感代码不敢用 AI”；
• 「模型选择」解决 “不同场景适配不同 AI 能力”；
• 「MCP 服务器」解决 “AI 无法对接本地工具 / 数据源”。

核心使用逻辑：先配置（Rules、MCP Server、知识库）→ 再使用（索引、审查、重构）→ 按场景选模型 / 模式，让 AI 从 “通用助手” 变成 “专属编码搭档”，大幅提升开发效率。