第1808篇：代码截图理解——让AI看懂IDE界面并给出建议
2026/4/30大约 16 分钟
第1808篇：代码截图理解——让AI看懂IDE界面并给出建议
一个真实的需求场景
有次参加一个内部分享，有人演示了这样一个功能：把IDE截图（包含代码、报错信息、代码补全提示）发给AI，AI直接分析截图里的代码问题并给出修改建议。
不是复制代码，是直接发截图。
当时我的第一反应是：这不就是把截图丢给GPT-4V吗，有什么技术含量？
然后我自己去做了一遍，发现这里面有很多细节：
- IDE截图里的代码字体渲染，行号、语法高亮如何干扰OCR
- 错误信息往往在截图底部，被部分遮挡
- 代码上下文不完整时，AI的建议质量会非常差
- 如何从截图里准确恢复代码的缩进结构（Python尤其重要）
所以这不是"丢截图给VLM"就完了，是一个完整的工程问题。这篇来拆解。
IDE截图的特殊性
IDE截图和普通文档截图有几个显著区别：
这些特性决定了专门处理IDE截图的策略必须有针对性。
截图预处理：让代码更可读
@Component
public class IdeScreenshotPreprocessor {
/**
* IDE截图预处理流水线
*/
public PreprocessedScreenshot preprocess(byte[] screenshotData) {
BufferedImage image = ImageIO.read(new ByteArrayInputStream(screenshotData));
// Step1: 识别IDE类型（用于后续策略选择）
IdeType ideType = detectIdeType(image);
// Step2: 识别并分割各面板区域
List<PanelRegion> panels = detectPanels(image, ideType);
// Step3: 对代码区域做增强处理
Map<PanelType, BufferedImage> enhancedPanels = new HashMap<>();
for (PanelRegion panel : panels) {
BufferedImage panelImage = cropImage(image, panel.getBounds());
BufferedImage enhanced = enhancePanelForOcr(panelImage, panel.getType());
enhancedPanels.put(panel.getType(), enhanced);
}
return PreprocessedScreenshot.builder()
.originalImage(image)
.ideType(ideType)
.panels(panels)
.enhancedPanels(enhancedPanels)
.build();
}
/**
* IDE类型检测
* 通过UI特征判断是VS Code、IntelliJ还是其他
*/
private IdeType detectIdeType(BufferedImage image) {
// 简单策略：检测特征颜色和布局
// VS Code：深色主题多，侧边栏固定宽度
// IntelliJ：通常有复杂的工具栏
// Eclipse：老式UI风格
// 实际可以用小型分类模型，这里用颜色统计简单判断
Color dominantColor = getDominantColor(image,
new Rectangle(0, 0, 50, image.getHeight())); // 侧边栏颜色
// VS Code暗色主题侧边栏是#252526
if (isColorSimilar(dominantColor, new Color(37, 37, 38), 20)) {
return IdeType.VSCODE_DARK;
}
// IntelliJ暗色主题
if (isColorSimilar(dominantColor, new Color(43, 43, 43), 20)) {
return IdeType.INTELLIJ_DARK;
}
return IdeType.UNKNOWN;
}
/**
* 面板区域检测：分割代码区、终端区、调试区等
*/
private List<PanelRegion> detectPanels(BufferedImage image, IdeType ideType) {
List<PanelRegion> panels = new ArrayList<>();
int width = image.getWidth();
int height = image.getHeight();
// 检测水平分割线（代码区和终端区的边界通常是深色线）
int splitY = detectHorizontalSplit(image);
if (splitY > 0 && splitY < height * 0.9) {
// 上部：代码区
panels.add(PanelRegion.builder()
.type(PanelType.CODE_EDITOR)
.bounds(new Rectangle(0, 0, width, splitY))
.build());
// 下部：终端/调试区
PanelType bottomType = detectBottomPanelType(image, splitY);
panels.add(PanelRegion.builder()
.type(bottomType)
.bounds(new Rectangle(0, splitY, width, height - splitY))
.build());
} else {
// 没有分割，整体是代码区
panels.add(PanelRegion.builder()
.type(PanelType.CODE_EDITOR)
.bounds(new Rectangle(0, 0, width, height))
.build());
}
return panels;
}
/**
* 代码区域图像增强
* 目标：提高代码的OCR识别率
*/
private BufferedImage enhancePanelForOcr(BufferedImage panel, PanelType type) {
if (type == PanelType.CODE_EDITOR) {
return enhanceCodePanel(panel);
} else if (type == PanelType.TERMINAL) {
return enhanceTerminalPanel(panel);
}
return panel;
}
private BufferedImage enhanceCodePanel(BufferedImage panel) {
// 对于暗色主题：增加对比度，让代码文字更清晰
BufferedImage enhanced = new BufferedImage(
panel.getWidth(), panel.getHeight(), BufferedImage.TYPE_INT_RGB);
for (int x = 0; x < panel.getWidth(); x++) {
for (int y = 0; y < panel.getHeight(); y++) {
int rgb = panel.getRGB(x, y);
int r = (rgb >> 16) & 0xFF;
int g = (rgb >> 8) & 0xFF;
int b = rgb & 0xFF;
// 将代码文字颜色向白色拉（针对暗色主题）
// 低亮度的背景变深黑，高亮度的文字变纯白
double brightness = (r * 0.299 + g * 0.587 + b * 0.114) / 255.0;
int newValue = brightness > 0.5 ? 255 : 0;
enhanced.setRGB(x, y, (newValue << 16) | (newValue << 8) | newValue);
}
}
return enhanced;
}
}代码提取：最核心的步骤
把截图里的代码准确恢复，是整个方案的核心：
@Component
public class CodeExtractor {
@Autowired
private VisionModelClient visionClient;
@Autowired
private OcrService ocrService;
/**
* 两阶段代码提取策略
*/
public CodeExtractionResult extract(BufferedImage codePanel) {
// 阶段1：OCR粗提取（快速，保留缩进）
OcrResult ocrResult = ocrService.extractWithLayout(imageToBytes(codePanel));
// 阶段2：VLM精细化修复
CodeExtractionResult refined = refineWithVlm(codePanel, ocrResult);
return refined;
}
/**
* 用VLM修复OCR的错误并恢复代码结构
* 这一步是关键：VLM能理解代码语义，修正OCR错误
*/
private CodeExtractionResult refineWithVlm(BufferedImage codePanel,
OcrResult ocrResult) {
String ocrText = ocrResult.getText();
String prompt = String.format("""
这是一张IDE代码截图。OCR识别的初步结果如下：
```
%s
```
请完成以下任务：
1. 对照截图，修正OCR识别错误（特别注意：括号匹配、特殊字符、缩进空格数量）
2. 识别编程语言
3. 如果有行号，去除行号只保留代码
4. 保持原始缩进（缩进是代码结构的一部分，不能随意修改）
5. 识别截图中高亮的行或有错误标注的位置（通常是红色波浪线、红色行号）
返回JSON格式：
{
"language": "编程语言",
"code": "修正后的完整代码（保持缩进）",
"highlighted_lines": [高亮行号列表],
"error_lines": [
{
"line_number": 行号,
"error_indicator": "错误指示符描述（如红色下划线、错误图标）"
}
],
"visible_line_range": "可见的行号范围（如1-45）",
"is_complete": 截图中的代码是否完整（true/false）
}
只返回JSON，不要其他说明。
""", ocrText);
String response = visionClient.analyze(imageToBytes(codePanel), prompt);
return parseCodeExtractionResult(response);
}
/**
* 行号去除：识别并剥离行号
* IDE行号的特征：在左侧、数字、与代码有固定间距
*/
private String removeLineNumbers(String text) {
// 匹配行首的行号格式：" 1 │ code" 或 "1: code" 等
return text.replaceAll("^\\s*\\d+\\s*[│|:]?\\s*", "");
}
}错误信息提取与分析
截图里的错误信息是最有价值的部分：
@Component
public class ErrorAnalyzer {
@Autowired
private VisionModelClient visionClient;
@Autowired
private LlmClient llmClient;
/**
* 从截图中提取所有错误信息
* 包括：编译错误、运行时异常、IDE警告、终端输出的异常栈
*/
public ErrorAnalysisResult analyzeErrors(PreprocessedScreenshot screenshot) {
List<ErrorInfo> errors = new ArrayList<>();
// 分析代码编辑器区的错误标注
Map<PanelType, BufferedImage> panels = screenshot.getEnhancedPanels();
if (panels.containsKey(PanelType.CODE_EDITOR)) {
errors.addAll(extractInlineErrors(panels.get(PanelType.CODE_EDITOR)));
}
// 分析终端/控制台区的异常输出
if (panels.containsKey(PanelType.TERMINAL)) {
errors.addAll(extractTerminalErrors(panels.get(PanelType.TERMINAL)));
}
// 分析错误面板（IntelliJ的Problems面板、VS Code的Problems面板）
if (panels.containsKey(PanelType.PROBLEMS_PANEL)) {
errors.addAll(extractProblemsPanel(panels.get(PanelType.PROBLEMS_PANEL)));
}
return ErrorAnalysisResult.builder()
.errors(errors)
.errorCount(errors.size())
.severity(determineSeverity(errors))
.build();
}
/**
* 提取代码编辑器中的内联错误标注
*/
private List<ErrorInfo> extractInlineErrors(BufferedImage codePanel) {
String prompt = """
请分析这张IDE代码截图，找出所有错误和警告标注：
1. 红色波浪线下面的代码通常是语法/类型错误
2. 红色圆圈或X图标通常是编译错误
3. 黄色波浪线通常是警告
4. 代码行旁边的红色竖条或颜色变化
对每个发现的错误，提取：
- 错误位置（大约在第几行）
- 错误类型（语法错误/类型错误/未定义变量等）
- 错误的代码内容
- IDE显示的错误消息（如果可见）
返回JSON数组：
[
{
"line": 行号（近似）,
"error_type": "错误类型",
"code_snippet": "错误处的代码",
"ide_message": "IDE显示的错误消息（如果可见）",
"severity": "ERROR/WARNING/INFO"
}
]
如果没有明显错误标注，返回空数组[]。
""";
String response = visionClient.analyze(imageToBytes(codePanel), prompt);
return parseErrorList(response);
}
/**
* 提取终端异常栈
*/
private List<ErrorInfo> extractTerminalErrors(BufferedImage terminal) {
String prompt = """
请分析这张终端/控制台截图，提取所有异常和错误信息。
重点关注：
1. Exception/Error/Caused by 开头的行
2. at xxx.method(xxx.java:行号) 格式的堆栈帧
3. 红色文字或错误级别的日志
返回JSON格式：
{
"has_exception": true/false,
"exception_type": "异常类型（如NullPointerException）",
"exception_message": "异常消息",
"stack_trace": ["堆栈帧1", "堆栈帧2", ...],
"root_cause": "根本原因（Caused by的第一条）",
"error_logs": ["其他错误日志行"]
}
""";
String response = visionClient.analyze(imageToBytes(terminal), prompt);
return parseTerminalErrors(response);
}
/**
* 生成修复建议
* 综合代码内容 + 错误信息，给出具体可行的建议
*/
public List<FixSuggestion> generateFixSuggestions(CodeExtractionResult code,
ErrorAnalysisResult errors) {
if (errors.getErrors().isEmpty()) return Collections.emptyList();
String errorsDescription = errors.getErrors().stream()
.map(e -> String.format("第%d行：%s - %s",
e.getLine(), e.getErrorType(), e.getIdeMessage()))
.collect(Collectors.joining("\n"));
String prompt = String.format("""
以下是一段%s代码和其中的错误信息：
【代码】：
```%s
%s
```
【错误信息】：
%s
请给出具体的修复建议：
1. 分析每个错误的根本原因
2. 给出修改后的代码（只修改有问题的部分）
3. 如果有多个错误，按优先级排序（先修核心错误）
4. 给出简单的解释，帮助开发者理解为什么这样改
返回JSON数组：
[
{
"error_line": 错误行号,
"root_cause": "根本原因分析",
"fix_description": "修复方案说明",
"original_code": "原始代码行",
"fixed_code": "修复后的代码行",
"explanation": "为什么这样改"
}
]
""", code.getLanguage(), code.getLanguage(), code.getCode(), errorsDescription);
String response = llmClient.complete(prompt);
return parseFixSuggestions(response);
}
}代码上下文补全
截图里的代码通常不完整，要让AI理解完整的上下文：
@Component
public class CodeContextEnricher {
@Autowired
private LlmClient llmClient;
/**
* 当截图代码不完整时，推断可能的上下文
* 这个功能能显著提升建议质量
*/
public EnrichedCodeContext enrich(CodeExtractionResult extracted) {
if (extracted.isComplete()) {
// 代码完整，不需要补全
return EnrichedCodeContext.builder()
.code(extracted.getCode())
.language(extracted.getLanguage())
.isEnriched(false)
.build();
}
// 代码不完整，推断上下文
String inferPrompt = String.format("""
以下是从IDE截图中提取的代码片段（不完整，截图只显示了部分代码）：
```%s
%s
```
请分析并推断：
1. 这段代码可能属于什么类/函数
2. 缺失的导入语句（import）可能是什么
3. 可见代码引用的变量/方法，在截图外可能如何定义
4. 代码的整体用途是什么
你的回答将帮助提供更准确的错误分析，所以尽量准确推断。
返回JSON格式：
{
"probable_class_context": "可能所属的类/模块",
"probable_imports": ["可能的导入"],
"inferred_variable_types": {
"变量名": "推断的类型"
},
"code_purpose": "代码用途推断"
}
""", extracted.getLanguage(), extracted.getCode());
String contextJson = llmClient.complete(inferPrompt);
InferredContext inferred = parseInferredContext(contextJson);
return EnrichedCodeContext.builder()
.code(extracted.getCode())
.language(extracted.getLanguage())
.inferredContext(inferred)
.isEnriched(true)
.build();
}
}完整的IDE截图分析服务
把上面所有组件串起来：
@Service
public class IdeScreenshotAnalysisService {
@Autowired
private IdeScreenshotPreprocessor preprocessor;
@Autowired
private CodeExtractor codeExtractor;
@Autowired
private ErrorAnalyzer errorAnalyzer;
@Autowired
private CodeContextEnricher contextEnricher;
@Autowired
private VisionModelClient visionClient;
@Autowired
private LlmClient llmClient;
/**
* 完整分析流程
*/
public AnalysisReport analyzeScreenshot(byte[] screenshotData) {
// Step1: 预处理
PreprocessedScreenshot preprocessed = preprocessor.preprocess(screenshotData);
// Step2: 代码提取
BufferedImage codePanel = preprocessed.getEnhancedPanels()
.get(PanelType.CODE_EDITOR);
CodeExtractionResult codeResult = null;
if (codePanel != null) {
codeResult = codeExtractor.extract(codePanel);
}
// Step3: 错误分析
ErrorAnalysisResult errorResult = errorAnalyzer.analyzeErrors(preprocessed);
// Step4: 上下文补全
EnrichedCodeContext enrichedContext = null;
if (codeResult != null) {
enrichedContext = contextEnricher.enrich(codeResult);
}
// Step5: 综合分析（对整个截图做整体理解）
OverallAnalysis overallAnalysis = performOverallAnalysis(
preprocessed, codeResult, errorResult, enrichedContext);
// Step6: 生成修复建议
List<FixSuggestion> suggestions = null;
if (codeResult != null && !errorResult.getErrors().isEmpty()) {
suggestions = errorAnalyzer.generateFixSuggestions(codeResult, errorResult);
}
return AnalysisReport.builder()
.ideType(preprocessed.getIdeType())
.language(codeResult != null ? codeResult.getLanguage() : "UNKNOWN")
.extractedCode(codeResult != null ? codeResult.getCode() : null)
.errors(errorResult.getErrors())
.overallAnalysis(overallAnalysis)
.fixSuggestions(suggestions)
.build();
}
/**
* 对整个截图做全局分析
* 不只看代码，还看开发者的工作状态和上下文
*/
private OverallAnalysis performOverallAnalysis(
PreprocessedScreenshot screenshot,
CodeExtractionResult code,
ErrorAnalysisResult errors,
EnrichedCodeContext context) {
String prompt = buildOverallAnalysisPrompt(code, errors, context);
// 用原始截图做分析（不用预处理版本，要保留颜色信息）
String response = visionClient.analyze(
imageToBytes(screenshot.getOriginalImage()), prompt);
return parseOverallAnalysis(response);
}
private String buildOverallAnalysisPrompt(CodeExtractionResult code,
ErrorAnalysisResult errors,
EnrichedCodeContext context) {
StringBuilder prompt = new StringBuilder();
prompt.append("请分析这张IDE截图，给出全面的代码质量分析和建议。\n\n");
if (code != null) {
prompt.append(String.format("编程语言：%s\n", code.getLanguage()));
if (!code.isComplete()) {
prompt.append("注意：截图只显示了部分代码，上下文可能不完整。\n");
}
}
if (errors != null && !errors.getErrors().isEmpty()) {
prompt.append(String.format("发现%d个错误/警告，请重点分析这些问题。\n",
errors.getErrorCount()));
}
if (context != null && context.isEnriched()) {
prompt.append(String.format("代码推断用途：%s\n",
context.getInferredContext().getCodePurpose()));
}
prompt.append("""
请提供：
1. 问题概述（最重要的1-3个问题）
2. 每个问题的根本原因分析
3. 具体的修改建议（带代码示例）
4. 代码改进建议（不只是修错误，还有最佳实践）
5. 如果是初学者常见的错误，给出学习建议
回答要简洁直接，以开发者视角给建议，不要过度解释。
返回JSON格式：
{
"problem_count": 问题数量,
"main_issues": ["主要问题描述"],
"detailed_analysis": [
{
"issue": "问题描述",
"root_cause": "根本原因",
"fix": "修复代码示例",
"explanation": "解释"
}
],
"code_quality_score": 1-10分（整体代码质量评分）,
"best_practice_tips": ["最佳实践建议"],
"learning_resources": ["如果是常见问题，推荐的学习方向"]
}
""");
return prompt.toString();
}
}特殊场景：调试截图分析
有时候截图包含调试状态（断点、变量监视窗口），这也是很有价值的分析场景：
@Component
public class DebugStateAnalyzer {
@Autowired
private VisionModelClient visionClient;
/**
* 分析调试状态截图
* 调试截图包含：当前执行位置、变量值、调用栈
*/
public DebugAnalysisResult analyzeDebugState(byte[] debugScreenshot) {
String prompt = """
这是一张代码调试状态的截图，可能包含：
- 代码编辑器（当前执行行通常有高亮或箭头标记）
- 变量监视窗口（Variables/Watch面板，显示变量当前值）
- 调用栈（Call Stack面板，显示函数调用层级）
- 断点标记
请提取以下信息：
1. 当前执行位置（第几行？哪个函数？）
2. 局部变量的当前值（从Variables面板读取）
3. 调用栈（从里到外的函数调用链）
4. 是否有异常被捕获/暂停
分析层面：
5. 根据当前变量值，判断程序执行是否符合预期
6. 可能的问题所在
7. 建议的下一步调试行动
返回JSON格式：
{
"current_execution": {
"file": "文件名",
"line": 行号,
"function": "当前函数名"
},
"local_variables": [
{
"name": "变量名",
"type": "类型",
"value": "当前值",
"is_suspicious": 值是否异常（true/false）
}
],
"call_stack": ["outerFunction", "innerFunction", "currentFunction"],
"exception_paused": null或"异常类型",
"anomalies": ["发现的异常情况"],
"diagnosis": "根据调试状态的问题诊断",
"next_steps": ["建议的下一步调试操作"]
}
""";
String response = visionClient.analyze(debugScreenshot, prompt);
return parseDebugAnalysis(response);
}
}代码补全建议：基于光标上下文
VS Code等IDE有时候会弹出补全建议列表，截图里能看到：
@Component
public class CompletionSuggestionAnalyzer {
@Autowired
private VisionModelClient visionClient;
/**
* 分析截图中的代码补全建议
* 帮助用户理解每个补全选项的含义
*/
public CompletionAnalysisResult analyzeCompletions(byte[] screenshot) {
String prompt = """
这张截图中可能包含代码自动补全下拉列表（intellisense/code completion）。
如果有补全列表，请提取：
1. 当前正在输入的代码前缀
2. 补全列表中的选项（通常是方法名、属性名等）
3. 每个选项的类型标识（方法、属性、变量、类等）
4. 当前高亮选中的选项
对每个选项：
- 解释它的用途
- 当前上下文中应该选哪个（给出推荐）
- 为什么推荐这个
返回JSON格式：
{
"has_completion_list": true/false,
"input_prefix": "当前输入前缀",
"completion_options": [
{
"name": "选项名",
"type": "METHOD/PROPERTY/VARIABLE/CLASS",
"is_selected": 是否高亮选中,
"description": "功能描述",
"recommended": 是否推荐（true/false）,
"recommendation_reason": "推荐原因"
}
],
"top_recommendation": "最推荐的选项和简单理由"
}
""";
String response = visionClient.analyze(screenshot, prompt);
return parseCompletionAnalysis(response);
}
}聊天式交互：连续追问
好的IDE截图分析工具应该支持连续对话，而不是单次问答：
@Service
public class IdeAssistantChatService {
private final Map<String, ChatSession> sessions = new ConcurrentHashMap<>();
@Data
private static class ChatSession {
private String sessionId;
private AnalysisReport lastReport;
private String currentCode;
private List<ChatMessage> history = new ArrayList<>();
}
/**
* 初始化会话：上传截图并分析
*/
public ChatResponse startSession(byte[] screenshot) {
String sessionId = UUID.randomUUID().toString();
AnalysisReport report = analysisService.analyzeScreenshot(screenshot);
ChatSession session = new ChatSession();
session.setSessionId(sessionId);
session.setLastReport(report);
session.setCurrentCode(report.getExtractedCode());
// 生成初始回复
String initialResponse = generateInitialResponse(report);
session.getHistory().add(new ChatMessage("assistant", initialResponse));
sessions.put(sessionId, session);
return ChatResponse.builder()
.sessionId(sessionId)
.message(initialResponse)
.codeExtracted(report.getExtractedCode())
.errorsFound(report.getErrors().size())
.build();
}
/**
* 追问：用户可以继续提问
*/
public ChatResponse chat(String sessionId, String userMessage) {
ChatSession session = sessions.get(sessionId);
if (session == null) {
return ChatResponse.error("会话不存在或已过期");
}
session.getHistory().add(new ChatMessage("user", userMessage));
// 构建包含代码上下文的对话
String contextualPrompt = buildContextualPrompt(session, userMessage);
String response = llmClient.complete(contextualPrompt);
session.getHistory().add(new ChatMessage("assistant", response));
return ChatResponse.builder()
.sessionId(sessionId)
.message(response)
.build();
}
private String buildContextualPrompt(ChatSession session, String userMessage) {
StringBuilder prompt = new StringBuilder();
// 系统上下文：告诉模型当前代码是什么
prompt.append("你是一个代码助手，正在帮助开发者分析以下代码：\n\n");
if (session.getCurrentCode() != null) {
prompt.append("```").append(session.getLastReport().getLanguage()).append("\n");
prompt.append(session.getCurrentCode()).append("\n```\n\n");
}
if (!session.getLastReport().getErrors().isEmpty()) {
prompt.append("之前分析发现的错误：\n");
session.getLastReport().getErrors().forEach(e ->
prompt.append("- ").append(e.toString()).append("\n"));
prompt.append("\n");
}
// 对话历史
prompt.append("对话历史：\n");
// 只取最近5轮
List<ChatMessage> recentHistory = session.getHistory();
int startIdx = Math.max(0, recentHistory.size() - 10);
for (int i = startIdx; i < recentHistory.size(); i++) {
ChatMessage msg = recentHistory.get(i);
prompt.append(msg.getRole()).append(": ").append(msg.getContent()).append("\n");
}
prompt.append("\nuser: ").append(userMessage);
return prompt.toString();
}
/**
* 生成分析完成后的初始回复
*/
private String generateInitialResponse(AnalysisReport report) {
StringBuilder response = new StringBuilder();
response.append(String.format("我已分析了这张IDE截图（%s代码）。\n\n",
report.getLanguage()));
if (report.getErrors().isEmpty()) {
response.append("好消息：没有发现明显的编译错误或语法问题。\n");
} else {
response.append(String.format("发现了%d个问题需要注意：\n\n",
report.getErrors().size()));
// 列出主要问题
report.getErrors().stream().limit(3).forEach(e -> {
response.append(String.format("• **第%d行**：%s\n",
e.getLine(), e.getErrorType()));
});
}
if (report.getFixSuggestions() != null && !report.getFixSuggestions().isEmpty()) {
response.append("\n我已准备好修复建议，你可以问我：\n");
response.append("- 怎么修复第X行的错误\n");
response.append("- 解释一下这个错误的原因\n");
response.append("- 整段代码有没有其他改进建议\n");
}
return response.toString();
}
}踩坑总结
坑1：等宽字体的OCR问题
代码字体（Consolas、Fira Code等）在普通OCR下识别率不如印刷体，特别是1/l/I、0/O、{/(这些容易混淆的字符。必须用专门的代码识别模式，或者直接用VLM来识别（准确率明显更好）。
坑2：缩进是命根子
Python代码的缩进决定了代码块层级，OCR提取时如果把4个空格识别成3个，就直接改变了代码语义。要在提取Prompt里特别强调"缩进数量要精确保留"。
坑3：暗色主题的颜色语义
在VS Code暗色主题里，不同颜色的代码代表不同语义（紫色=关键词、蓝色=变量、橙色=函数调用等），这些颜色信息对于代码理解很有价值，但简单的二值化处理会丢失。要保留原始截图给VLM分析，不能只用预处理版本。
坑4：多显示器、高DPI截图
MacBook的Retina屏幕截图是2x分辨率，同样的IDE内容，实际像素尺寸是普通屏幕的4倍。要在预处理时做分辨率归一化，否则区域检测的坐标会全部偏移。
小结
IDE截图理解，工程挑战集中在：
- 预处理要针对IDE特性：行号去除、暗色主题处理、多面板分割
- OCR + VLM双阶段：OCR快速粗提取，VLM精细化修复
- 错误多点提取：内联标注、终端异常、Problems面板要分别处理
- 上下文补全很重要：截图代码通常不完整，要推断上下文
- 对话式体验更好用：一问一答不够，连续追问才是实用功能
这个功能很有价值——很多情况下用户懒得复制代码，直接截图发过来问，如果AI能准确理解并给出建议，体验会非常好。