Update app.py

app.py

@@ -1,13 +1,14 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-Capricode Vision Pro - 完整的代码视觉定位系统
+Capricode Vision Pro - 升级版代码视觉定位系统
 """
 import gradio as gr
 import re
 from typing import Dict, List, Tuple, Any, Optional
 from dataclasses import dataclass
 import time
+import json
 
 @dataclass
 class QuantumPosition:
@@ -29,6 +30,10 @@ class PrecisionCodeVision:
         """
         lines = code.split('\n')
         
+        # 边界检查增强
+        if cursor_line < 0 or cursor_line >= len(lines) or cursor_column < 0:
+            return self._handle_invalid_position(cursor_line, cursor_column)
+        
         # 1. 绝对位置校准
         absolute_position = self._calibrate_absolute_position(lines, cursor_line, cursor_column)
         
@@ -42,7 +47,7 @@ class PrecisionCodeVision:
         structure_map = self._create_structure_mapping(code, lines)
         
         # 5. 修复建议定位
-        repair_locations = self._calculate_repair_locations(structure_map, absolute_position)
+        repair_locations = self._calculate_repair_locations(structure_map, absolute_position, lines, cursor_line)
         
         return {
             "quantum_position": absolute_position,
@@ -50,11 +55,40 @@ class PrecisionCodeVision:
             "scope_precision": scope_context,
             "structure_mapping": structure_map,
             "repair_targets": repair_locations,
-            "confidence_score": self._calculate_confidence(lines, cursor_line)
+            "confidence_score": self._calculate_confidence(lines, cursor_line, cursor_column)
+        }
+    
+    def _handle_invalid_position(self, line: int, column: int) -> Dict[str, Any]:
+        """处理无效位置"""
+        return {
+            "quantum_position": {
+                "absolute_line": max(0, line),
+                "relative_line": 0,
+                "column": max(0, column),
+                "scope_depth": 0,
+                "context_hash": "invalid_position",
+                "semantic_position": "无效位置"
+            },
+            "semantic_context": {
+                "current_token": "",
+                "statement_type": "invalid",
+                "is_inside_string": False,
+                "is_inside_comment": False,
+                "surrounding_tokens": []
+            },
+            "scope_precision": {
+                "scope_type": "invalid_scope",
+                "scope_boundary": {"start": 0, "end": 0},
+                "accessible_variables": [],
+                "scope_hierarchy": []
+            },
+            "structure_mapping": {"syntactic_elements": {}},
+            "repair_targets": [],
+            "confidence_score": 0.1  # 大幅降低无效位置的置信度
         }
     
     def _calibrate_absolute_position(self, lines: List[str], line: int, column: int) -> QuantumPosition:
-        """绝对位置校准"""
+        """绝对位置校准 - 增强边界处理"""
         if line >= len(lines):
             line = len(lines) - 1
         if column >= len(lines[line]):
@@ -81,15 +115,17 @@ class PrecisionCodeVision:
         return line - scope_start + 1
     
     def _calculate_scope_depth(self, lines: List[str], line: int) -> int:
-        """计算作用域深度"""
+        """计算作用域深度 - 改进算法"""
         depth = 0
+        brace_count = 0
         for i in range(line + 1):
             current_line = lines[i]
+            # 计算大括号嵌套
+            brace_count += current_line.count('{')
+            brace_count -= current_line.count('}')
+            # 计算缩进
             indent = len(current_line) - len(current_line.lstrip())
-            depth = max(depth, indent // 2)
-            
-            if any(keyword in current_line for keyword in ['{', '}', 'def ', 'class ', 'if ', 'for ']):
-                depth += current_line.count('{') - current_line.count('}')
+            depth = max(depth, brace_count + indent // 4)
         return max(0, depth)
     
     def _generate_position_hash(self, lines: List[str], line: int, column: int) -> str:
@@ -105,24 +141,43 @@ class PrecisionCodeVision:
         return str(hash(context))
     
     def _get_semantic_label(self, lines: List[str], line: int, column: int) -> str:
-        """获取语义标签"""
-        current_line = lines[line] if line < len(lines) else ""
+        """获取语义标签 - 增强识别"""
+        if line >= len(lines):
+            return "无效位置"
+            
+        current_line = lines[line]
         
-        if 'function' in current_line:
+        # 增强的语义识别
+        if self._is_inside_comment(current_line, column):
+            return "注释内"
+        elif self._is_inside_string(current_line, column):
+            return "字符串内"
+        elif re.search(r'\bfunction\b', current_line):
             return "函数定义内"
-        elif 'class' in current_line:
+        elif re.search(r'\bclass\b', current_line):
             return "类定义内"
-        elif any(keyword in current_line for keyword in ['if', 'for', 'while']):
+        elif any(re.search(rf'\b{keyword}\b', current_line) for keyword in ['if', 'for', 'while', 'switch']):
             return "控制流语句内"
-        elif 'import' in current_line:
+        elif any(keyword in current_line for keyword in ['import', 'from', 'require']):
             return "导入语句"
+        elif any(keyword in current_line for keyword in ['const', 'let', 'var', 'def']):
+            return "变量声明"
         else:
             return "代码语句内"
     
     def _analyze_semantic_position(self, code: str, line: int, column: int) -> Dict[str, Any]:
-        """语义位置分析"""
+        """语义位置分析 - 增强上下文"""
         lines = code.split('\n')
-        current_line = lines[line] if line < len(lines) else ""
+        if line >= len(lines):
+            return {
+                "current_token": "",
+                "statement_type": "invalid",
+                "is_inside_string": False,
+                "is_inside_comment": False,
+                "surrounding_tokens": []
+            }
+            
+        current_line = lines[line]
         
         return {
             "current_token": self._extract_current_token(current_line, column),
@@ -133,7 +188,15 @@ class PrecisionCodeVision:
         }
     
     def _precise_scope_analysis(self, lines: List[str], line: int, column: int) -> Dict[str, Any]:
-        """精准作用域分析"""
+        """精准作用域分析 - 增强变量识别"""
+        if line >= len(lines):
+            return {
+                "scope_type": "invalid_scope",
+                "scope_boundary": {"start": 0, "end": 0},
+                "accessible_variables": [],
+                "scope_hierarchy": []
+            }
+            
         scope_start = self._find_scope_start(lines, line)
         scope_end = self._find_scope_end(lines, line)
         
@@ -148,59 +211,107 @@ class PrecisionCodeVision:
         }
     
     def _extract_current_token(self, line: str, column: int) -> str:
-        """提取当前token"""
-        if column >= len(line):
+        """提取当前token - 改进算法"""
+        if column >= len(line) or column < 0:
             return ""
-        words = line.split()
-        for word in words:
-            if word in line[:column]:
-                return word
-        return line[max(0, column-5):min(len(line), column+5)]
+        
+        # 找到当前单词的起始和结束位置
+        start = column
+        while start > 0 and line[start-1].isalnum():
+            start -= 1
+            
+        end = column
+        while end < len(line) and line[end].isalnum():
+            end += 1
+            
+        return line[start:end] if start < end else ""
     
     def _classify_statement_type(self, line: str) -> str:
-        """分类语句类型"""
+        """分类语句类型 - 增强识别"""
         line = line.strip()
-        if line.startswith('def '):
+        if re.search(r'^def\s+', line):
             return "function_definition"
-        elif line.startswith('class '):
+        elif re.search(r'^class\s+', line):
             return "class_definition"
-        elif any(line.startswith(keyword) for keyword in ['if ', 'for ', 'while ']):
+        elif any(re.search(rf'^{keyword}\s+', line) for keyword in ['if', 'for', 'while']):
             return "control_flow"
-        elif any(keyword in line for keyword in ['import ', 'from ']):
+        elif any(keyword in line for keyword in ['import', 'from', 'require']):
             return "import_statement"
-        elif '=' in line:
+        elif any(keyword in line for keyword in ['const', 'let', 'var']):
+            return "variable_declaration"
+        elif '=' in line and '==' not in line:
             return "assignment"
+        elif line.endswith(':'):
+            return "block_statement"
         else:
             return "expression"
     
     def _is_inside_string(self, line: str, column: int) -> bool:
-        """检查是否在字符串内"""
-        return line.count('"', 0, column) % 2 == 1 or line.count("'", 0, column) % 2 == 1
+        """检查是否在字符串内 - 改进算法"""
+        if column >= len(line):
+            return False
+            
+        in_single_quote = False
+        in_double_quote = False
+        escape_next = False
+        
+        for i, char in enumerate(line):
+            if i > column:
+                break
+                
+            if escape_next:
+                escape_next = False
+                continue
+                
+            if char == '\\':
+                escape_next = True
+                continue
+                
+            if char == "'" and not in_double_quote:
+                in_single_quote = not in_single_quote
+            elif char == '"' and not in_single_quote:
+                in_double_quote = not in_double_quote
+                
+        return in_single_quote or in_double_quote
     
     def _is_inside_comment(self, line: str, column: int) -> bool:
-        """检查是否在注释内"""
-        return '//' in line[:column] or '/*' in line[:column] or line.strip().startswith('#')
+        """检查是否在注释内 - 改进算法"""
+        if column >= len(line):
+            return False
+            
+        line_before_cursor = line[:column]
+        return '//' in line_before_cursor or '/*' in line_before_cursor or line.strip().startswith('#')
     
     def _get_surrounding_tokens(self, lines: List[str], line: int, column: int) -> List[str]:
-        """获取周围token"""
+        """获取周围token - 增强上下文"""
         tokens = []
         start = max(0, line - 1)
         end = min(len(lines), line + 2)
         
         for i in range(start, end):
-            tokens.extend(lines[i].split())
+            # 使用正则表达式分割token，保留标点符号
+            line_tokens = re.findall(r'[a-zA-Z_]\w*|[0-9]+|\S', lines[i])
+            tokens.extend(line_tokens)
         
-        return tokens[:10]
+        return tokens[:15]  # 增加token数量
     
     def _find_scope_start(self, lines: List[str], line: int) -> int:
-        """查找作用域开始"""
+        """查找作用域开始 - 改进算法"""
+        brace_count = 0
         for i in range(line, -1, -1):
-            if any(keyword in lines[i] for keyword in ['{', 'def ', 'class ', 'if ', 'for ', 'function ']):
+            current_line = lines[i]
+            brace_count += current_line.count('}')
+            brace_count -= current_line.count('{')
+            
+            if brace_count < 0:  # 找到匹配的{
+                return i
+                
+            if any(re.search(rf'\b{keyword}\b', current_line) for keyword in ['function', 'class', 'if', 'for', 'while']):
                 return i
         return 0
     
     def _find_scope_end(self, lines: List[str], line: int) -> int:
-        """查找作用域结束"""
+        """查找作用域结束 - 改进算法"""
         brace_count = 0
         for i in range(line, len(lines)):
             brace_count += lines[i].count('{')
@@ -210,35 +321,41 @@ class PrecisionCodeVision:
         return len(lines) - 1
     
     def _detect_scope_type(self, lines: List[str], scope_start: int) -> str:
-        """检测作用域类型"""
+        """检测作用域类型 - 增强识别"""
+        if scope_start >= len(lines):
+            return "global_scope"
+            
         line = lines[scope_start]
-        if 'function' in line:
+        if re.search(r'\bfunction\b', line):
             return "function_scope"
-        elif 'class' in line:
+        elif re.search(r'\bclass\b', line):
             return "class_scope"
-        elif any(keyword in line for keyword in ['if', 'for', 'while']):
+        elif any(re.search(rf'\b{keyword}\b', line) for keyword in ['if', 'for', 'while']):
             return "control_flow_scope"
         else:
             return "global_scope"
     
     def _find_accessible_variables(self, lines: List[str], scope_start: int, scope_end: int, current_line: int) -> List[str]:
-        """查找可访问变量"""
+        """查找可访问变量 - 增强识别"""
         variables = []
         for i in range(scope_start, min(current_line + 1, scope_end + 1)):
             line = lines[i]
-            if '=' in line and '==' not in line:
-                parts = line.split('=')
-                if len(parts) > 0:
-                    var_part = parts[0].strip()
-                    if any(keyword in var_part for keyword in ['const ', 'let ', 'var ', 'def ']):
-                        var_name = var_part.split()[-1]
-                        variables.append(var_name)
-                    else:
-                        variables.append(var_part)
-        return list(set(variables))
+            # 增强变量识别模式
+            patterns = [
+                r'(?:const|let|var)\s+([a-zA-Z_]\w*)',
+                r'def\s+([a-zA-Z_]\w*)',
+                r'class\s+([a-zA-Z_]\w*)',
+                r'([a-zA-Z_]\w*)\s*='
+            ]
+            
+            for pattern in patterns:
+                matches = re.findall(pattern, line)
+                variables.extend(matches)
+                
+        return list(set(variables))  # 去重
     
     def _get_scope_hierarchy(self, lines: List[str], line: int) -> List[Dict[str, Any]]:
-        """获取作用域层次结构"""
+        """获取作用域层次结构 - 改进算法"""
         hierarchy = []
         current_line = line
         
@@ -252,11 +369,14 @@ class PrecisionCodeVision:
                 "start_line": scope_start + 1,
                 "end_line": scope_end + 1
             })
-            current_line = scope_start - 1
-            if scope_start == 0:
+            
+            # 如果已经是全局作用域，停止回溯
+            if scope_start == 0 or scope_type == "global_scope":
                 break
+                
+            current_line = scope_start - 1
         
-        return hierarchy[::-1]
+        return hierarchy[::-1]  # 反转列表，从外到内
     
     def _create_structure_mapping(self, code: str, lines: List[str]) -> Dict[str, Any]:
         """创建代码结构映射"""
@@ -270,10 +390,10 @@ class PrecisionCodeVision:
         }
     
     def _map_functions(self, lines: List[str]) -> List[Dict[str, Any]]:
-        """映射函数"""
+        """映射函数 - 增强识别"""
         functions = []
         for i, line in enumerate(lines):
-            if 'function' in line or 'def ' in line:
+            if re.search(r'\bfunction\b', line) or re.search(r'^def\s+', line):
                 functions.append({
                     "name": self._extract_function_name(line),
                     "line": i + 1,
@@ -282,33 +402,37 @@ class PrecisionCodeVision:
         return functions
     
     def _extract_function_name(self, line: str) -> str:
-        """提取函数名"""
-        if 'function' in line:
-            parts = line.split('function')
-            if len(parts) > 1:
-                name_part = parts[1].split('(')[0].strip()
-                return name_part
+        """提取函数名 - 改进算法"""
+        # 匹配 function name() 或 def name():
+        patterns = [
+            r'function\s+([a-zA-Z_]\w*)\s*\(',
+            r'def\s+([a-zA-Z_]\w*)\s*\('
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, line)
+            if match:
+                return match.group(1)
         return "anonymous"
     
     def _map_classes(self, lines: List[str]) -> List[Dict[str, Any]]:
-        """映射类"""
+        """映射类 - 增强识别"""
         classes = []
         for i, line in enumerate(lines):
-            if 'class' in line:
-                parts = line.split('class')
-                if len(parts) > 1:
-                    class_name = parts[1].split(':')[0].split('{')[0].strip()
+            if re.search(r'\bclass\b', line):
+                match = re.search(r'class\s+([a-zA-Z_]\w*)', line)
+                if match:
                     classes.append({
-                        "name": class_name,
+                        "name": match.group(1),
                         "line": i + 1
                     })
         return classes
     
     def _map_control_flows(self, lines: List[str]) -> List[Dict[str, Any]]:
-        """映射控制流"""
+        """映射控制流 - 增强识别"""
         controls = []
         for i, line in enumerate(lines):
-            if any(keyword in line for keyword in ['if ', 'for ', 'while ']):
+            if any(re.search(rf'\b{keyword}\b', line) for keyword in ['if', 'for', 'while', 'switch']):
                 controls.append({
                     "type": self._get_control_type(line),
                     "line": i + 1,
@@ -317,51 +441,65 @@ class PrecisionCodeVision:
         return controls
     
     def _get_control_type(self, line: str) -> str:
-        """获取控制类型"""
-        if 'if ' in line:
+        """获取控制类型 - 增强识别"""
+        if re.search(r'\bif\b', line):
             return "if_statement"
-        elif 'for ' in line:
+        elif re.search(r'\bfor\b', line):
             return "for_loop"
-        elif 'while ' in line:
+        elif re.search(r'\bwhile\b', line):
             return "while_loop"
+        elif re.search(r'\bswitch\b', line):
+            return "switch_statement"
         else:
             return "unknown"
     
     def _map_variables(self, lines: List[str]) -> List[Dict[str, Any]]:
-        """映射变量"""
+        """映射变量 - 增强识别"""
         variables = []
         for i, line in enumerate(lines):
-            if any(keyword in line for keyword in ['const ', 'let ', 'var ', ' = ']):
-                var_name = self._extract_variable_name(line)
-                if var_name:
+            # 增强变量识别模式
+            patterns = [
+                r'(?:const|let|var)\s+([a-zA-Z_]\w*)',
+                r'([a-zA-Z_]\w*)\s*='
+            ]
+            
+            for pattern in patterns:
+                matches = re.findall(pattern, line)
+                for match in matches:
                     variables.append({
-                        "name": var_name,
+                        "name": match,
                         "line": i + 1,
                     })
         return variables
     
-    def _extract_variable_name(self, line: str) -> str:
-        """提取变量名"""
-        if 'const ' in line:
-            return line.split('const ')[1].split('=')[0].split(';')[0].strip()
-        elif 'let ' in line:
-            return line.split('let ')[1].split('=')[0].split(';')[0].strip()
-        elif 'var ' in line:
-            return line.split('var ')[1].split('=')[0].split(';')[0].strip()
-        elif ' = ' in line:
-            return line.split(' = ')[0].strip()
-        return ""
-    
-    def _calculate_repair_locations(self, structure: Dict[str, Any], position: QuantumPosition) -> List[Dict[str, Any]]:
-        """计算修复位置"""
+    def _calculate_repair_locations(self, structure: Dict[str, Any], position: QuantumPosition, lines: List[str], cursor_line: int) -> List[Dict[str, Any]]:
+        """计算修复位置 - 增强建议"""
         locations = []
         
-        locations.append({
-            "type": "line_insert_before",
-            "line": position.absolute_line,
-            "description": "在当前行前插入",
-            "priority": 1,
-        })
+        # 根据语义位置提供更具体的建议
+        semantic_pos = position.semantic_position
+        
+        if "导入语句" in semantic_pos:
+            locations.append({
+                "type": "import_insert",
+                "line": position.absolute_line,
+                "description": "在导入区域添加新导入",
+                "priority": 1,
+            })
+        elif "函数" in semantic_pos:
+            locations.append({
+                "type": "function_insert",
+                "line": position.absolute_line,
+                "description": "在函数内插入代码",
+                "priority": 1,
+            })
+        else:
+            locations.append({
+                "type": "line_insert_before",
+                "line": position.absolute_line,
+                "description": "在当前行前插入",
+                "priority": 1,
+            })
         
         locations.append({
             "type": "line_insert_after", 
@@ -379,34 +517,67 @@ class PrecisionCodeVision:
         
         return locations
     
-    def _calculate_confidence(self, lines: List[str], cursor_line: int) -> float:
-        """计算置信度"""
-        if cursor_line < len(lines):
-            line = lines[cursor_line]
-            complexity = len(line.split()) / 10.0
-            return min(0.95, 0.7 + complexity)
-        return 0.7
+    def _calculate_confidence(self, lines: List[str], cursor_line: int, cursor_column: int) -> float:
+        """计算置信度 - 改进算法"""
+        if cursor_line >= len(lines) or cursor_line < 0:
+            return 0.1  # 无效位置低置信度
+            
+        line = lines[cursor_line]
+        
+        # 基础置信度
+        base_confidence = 0.7
+        
+        # 根据位置质量调整
+        if cursor_column < len(line):
+            # 检查是否在有效token上
+            token = self._extract_current_token(line, cursor_column)
+            if token:
+                base_confidence += 0.2
+                
+        # 根据代码复杂度调整
+        complexity = len(line.split()) / 15.0
+        base_confidence += min(0.25, complexity)
+        
+        return min(0.95, base_confidence)
 
-# ==================== Gradio 界面 ====================
+# ==================== 升级版 Gradio 界面 ====================
 
 # 创建视觉引擎实例
 vision_engine = PrecisionCodeVision()
 
+def format_code_with_line_numbers(code: str) -> str:
+    """为代码添加行号显示"""
+    if not code.strip():
+        return ""
+    
+    lines = code.split('\n')
+    formatted_lines = []
+    
+    for i, line in enumerate(lines, 1):
+        # 为每行添加行号
+        line_number = f"{i:3d} │ "  # 固定宽度行号
+        formatted_lines.append(f"{line_number}{line}")
+    
+    return "\n".join(formatted_lines)
+
 def analyze_code_with_cursor(code, cursor_line, cursor_column):
     """分析代码和光标位置"""
     if not code.strip():
-        return "请输入代码", {}, {}
+        return "请输入代码", {}, {}, ""
     
     try:
         cursor_line = int(cursor_line) - 1  # 转换为0-based
         cursor_column = int(cursor_column) - 1  # 转换为0-based
     except:
-        return "请输入有效的行号和列号", {}, {}
+        return "请输入有效的行号和列号", {}, {}, ""
     
     start_time = time.time()
     result = vision_engine.quantum_analyze(code, cursor_line, cursor_column)
     processing_time = (time.time() - start_time) * 1000
     
+    # 生成带行号的代码显示
+    code_with_lines = format_code_with_line_numbers(code)
+    
     # 生成分析报告
     quantum_pos = result['quantum_position']
     scope_info = result['scope_precision']
@@ -442,7 +613,11 @@ def analyze_code_with_cursor(code, cursor_line, cursor_column):
         "repair_suggestions": result['repair_targets'][:3]
     }
     
-    return report, result, visual_data
+    return report, result, visual_data, code_with_lines
+
+def clear_all():
+    """清空所有输入和输出"""
+    return "", 1, 1, "等待分析...", {}, {}, ""
 
 # 示例代码
 example_code = """function calculateTotal(items) {
@@ -459,37 +634,57 @@ function applyDiscount(total, discount) {
 
 # 创建Gradio界面
 with gr.Blocks(
-    title="Capricode Vision Pro - 代码视觉定位系统",
-    theme=gr.themes.Soft(primary_hue="blue")
+    title="Capricode Vision Pro - 升级版代码视觉定位系统",
+    theme=gr.themes.Soft(primary_hue="blue"),
+    css="""
+    .code-with-lines {
+        font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+        font-size: 14px;
+        line-height: 1.4;
+    }
+    .line-number {
+        color: #666;
+        background: #f5f5f5;
+        padding-right: 10px;
+        border-right: 1px solid #ddd;
+    }
+    """
 ) as demo:
     
     gr.Markdown("""
-    # 👁️ Capricode Vision Pro
-    ## 量子级精准代码定位系统
+    # 👁️ Capricode Vision Pro 
+    ## 🚀 升级版 - 量子级精准代码定位系统
     
-    **为LLM提供100%精准的代码视觉感知能力**
+    **基于测试经验全面优化，为LLM提供100%精准的代码视觉感知能力**
     """)
     
     with gr.Row():
         with gr.Column(scale=2):
-            code_input = gr.Textbox(
-                label="📝 代码输入",
-                value=example_code,
-                lines=15,
-                placeholder="在此输入或粘贴代码..."
-            )
+            with gr.Group():
+                gr.Markdown("### 📝 代码输入 (带行号显示)")
+                code_input = gr.Textbox(
+                    label="",
+                    value=example_code,
+                    lines=15,
+                    placeholder="在此输入或粘贴代码...",
+                    elem_classes=["code-with-lines"]
+                )
             
             with gr.Row():
-                cursor_line = gr.Number(
-                    label="📏 光标行号",
-                    value=4,
-                    precision=0
-                )
-                cursor_column = gr.Number(
-                    label="📐 光标列号", 
-                    value=8,
-                    precision=0
-                )
+                with gr.Column(scale=1):
+                    cursor_line = gr.Number(
+                        label="📏 光标行号",
+                        value=4,
+                        precision=0
+                    )
+                with gr.Column(scale=1):
+                    cursor_column = gr.Number(
+                        label="📐 光标列号", 
+                        value=8,
+                        precision=0
+                    )
+                with gr.Column(scale=1):
+                    clear_btn = gr.Button("🗑️ 清空所有", variant="secondary")
             
             analyze_btn = gr.Button("🔍 开始量子分析", variant="primary", size="lg")
         
@@ -508,21 +703,48 @@ with gr.Blocks(
             gr.Markdown("### 🎨 可视化")
             visual_output = gr.JSON(label="可视化数据")
     
+    # 新增：带行号的代码显示
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 📋 代码预览 (带行号)")
+            code_display = gr.Code(
+                label="",
+                language="python",
+                interactive=False,
+                lines=10,
+                value=format_code_with_line_numbers(example_code)
+            )
+    
     with gr.Row():
         gr.Markdown("""
-        ### 🚀 系统特性
-        - **量子级定位**: 解决行号偏移问题
-        - **语义感知**: 理解代码上下文含义  
-        - **作用域分析**: 精准识别变量可用性
-        - **修复引导**: 为LLM提供最优修复位置
-        - **实时响应**: 毫秒级分析速度
+        ### 🚀 系统特性 (升级版)
+        - **🎯 量子级定位**: 解决行号偏移问题，增强边界处理
+        - **🧠 语义感知**: 改进上下文理解，支持更多语法结构  
+        - **🔍 作用域分析**: 精准识别变量可用性，增强闭包变量识别
+        - **🛠️ 修复引导**: 为LLM提供语义感知的最优修复位置
+        - **⚡ 实时响应**: 毫秒级分析速度，置信度校准优化
+        - **📊 行号显示**: 直观的代码行号显示
+        - **🗑️ 一键清空**: 快速清空所有内容
         """)
     
     # 事件处理
     analyze_btn.click(
         fn=analyze_code_with_cursor,
         inputs=[code_input, cursor_line, cursor_column],
-        outputs=[report_output, json_output, visual_output]
+        outputs=[report_output, json_output, visual_output, code_display]
+    )
+    
+    # 清空按钮事件
+    clear_btn.click(
+        fn=clear_all,
+        outputs=[code_input, cursor_line, cursor_column, report_output, json_output, visual_output, code_display]
+    )
+    
+    # 代码输入变化时更新行号显示
+    code_input.change(
+        fn=format_code_with_line_numbers,
+        inputs=[code_input],
+        outputs=[code_display]
     )
     
     # 快速示例按钮
@@ -532,6 +754,7 @@ with gr.Blocks(
         vue_example_btn = gr.Button("Vue示例")
         python_example_btn = gr.Button("Python示例")
         js_example_btn = gr.Button("JavaScript示例")
+        nested_example_btn = gr.Button("深度嵌套测试")
     
     # 示例代码
     vue_example = """<template>
@@ -567,22 +790,37 @@ class MathUtils:
             total += num
         return total"""
 
+    nested_example = """function a() { 
+    function b() { 
+        function c() { 
+            function d() { 
+                return "deep nested"; 
+            } 
+        } 
+    } 
+}"""
+
     def load_example(example_code, line, column):
-        return example_code, line, column
+        return example_code, line, column, format_code_with_line_numbers(example_code)
     
     vue_example_btn.click(
         fn=lambda: load_example(vue_example, 8, 10),
-        outputs=[code_input, cursor_line, cursor_column]
+        outputs=[code_input, cursor_line, cursor_column, code_display]
     )
     
     python_example_btn.click(
         fn=lambda: load_example(python_example, 6, 8), 
-        outputs=[code_input, cursor_line, cursor_column]
+        outputs=[code_input, cursor_line, cursor_column, code_display]
     )
     
     js_example_btn.click(
         fn=lambda: load_example(example_code, 4, 8),
-        outputs=[code_input, cursor_line, cursor_column]
+        outputs=[code_input, cursor_line, cursor_column, code_display]
+    )
+    
+    nested_example_btn.click(
+        fn=lambda: load_example(nested_example, 4, 20),
+        outputs=[code_input, cursor_line, cursor_column, code_display]
     )
 
 # 启动应用