29.5.1 调试模块概述

调试模块是编程 Agent 的重要能力，它能够自动识别、定位和修复代码中的错误。调试涉及错误检测、根因分析、修复建议等多个环节。

调试流程

错误报告 ↓ 错误检测 ↓ 错误定位 ↓ 根因分析 ↓ 修复建议 ↓ 修复验证 ↓ 问题解决

29.5.2 错误检测

错误检测器

python

class ErrorDetector:
    """错误检测器"""

    def __init__(self):
        self.detectors = {
            'syntax': SyntaxErrorDetector(),
            'runtime': RuntimeErrorDetector(),
            'logic': LogicErrorDetector(),
            'performance': PerformanceErrorDetector(),
            'security': SecurityErrorDetector()
        }

    async def detect(self, code: str,
                     execution_result: ExecutionResult = None) -> List[DetectedError]:
        """检测错误"""
        errors = []

        # 运行各种检测器
        for detector_name, detector in self.detectors.items():
            try:
                detected = await detector.detect(code, execution_result)
                errors.extend(detected)
            except Exception as e:
                logger.error(f"Error in {detector_name} detector: {e}")

        # 去重
        errors = self._deduplicate_errors(errors)

        # 排序（按严重程度）
        errors.sort(key=lambda e: e.severity, reverse=True)

        return errors

    def _deduplicate_errors(self,
                            errors: List[DetectedError]) -> List[DetectedError]:
        """去重错误"""
        seen = set()
        unique_errors = []

        for error in errors:
            key = (error.type, error.location, error.message)
            if key not in seen:
                seen.add(key)
                unique_errors.append(error)

        return unique_errors

class SyntaxErrorDetector:
    """语法错误检测器"""

    async def detect(self, code: str,
                     execution_result: ExecutionResult = None) -> List[DetectedError]:
        """检测语法错误"""
        errors = []

        try:
            # 尝试编译代码
            compile(code, '<string>', 'exec')
        except SyntaxError as e:
            error = DetectedError(
                type='syntax',
                severity='high',
                location=f"Line {e.lineno}, Column {e.offset}",
                message=e.msg,
                code_snippet=self._get_code_snippet(code, e.lineno),
                suggestion=self._get_syntax_suggestion(e)
            )
            errors.append(error)

        return errors

    def _get_code_snippet(self, code: str, line_no: int) -> str:
        """获取代码片段"""
        lines = code.split('\n')
        if 1 <= line_no <= len(lines):
            return lines[line_no - 1]
        return ""

    def _get_syntax_suggestion(self, error: SyntaxError) -> str:
        """获取语法错误建议"""
        suggestions = {
            'invalid syntax': "检查语法是否正确，确保括号、引号等匹配",
            'unexpected EOF': "检查代码是否完整，确保所有括号都已闭合",
            'unterminated string literal': "检查字符串是否正确闭合",
            'expected an indented block': "检查缩进是否正确",
            'unindent does not match any outer indentation level': "检查缩进层级是否一致"
        }

        return suggestions.get(error.msg, "请检查语法错误")

class RuntimeErrorDetector:
    """运行时错误检测器"""

    async def detect(self, code: str,
                     execution_result: ExecutionResult = None) -> List[DetectedError]:
        """检测运行时错误"""
        errors = []

        if not execution_result or not execution_result.error:
            return errors

        # 分析错误信息
        error_info = self._parse_error(execution_result.error)

        error = DetectedError(
            type='runtime',
            severity='high',
            location=error_info.get('location', 'Unknown'),
            message=error_info.get('message', 'Unknown error'),
            code_snippet=error_info.get('code_snippet', ''),
            traceback=error_info.get('traceback', ''),
            suggestion=self._get_runtime_suggestion(error_info)
        )
        errors.append(error)

        return errors

    def _parse_error(self, error: str) -> Dict[str, str]:
        """解析错误信息"""
        error_info = {
            'message': error,
            'location': 'Unknown',
            'traceback': '',
            'code_snippet': ''
        }

        # 解析 traceback
        if 'Traceback' in error:
            lines = error.split('\n')
            for line in lines:
                if 'File' in line and 'line' in line:
                    # 提取文件和行号
                    parts = line.split(',')
                    if len(parts) >= 2:
                        error_info['location'] = parts[1].strip()
                elif line.strip() and not line.startswith(' ') and 'Error' in line:
                    error_info['message'] = line.strip()

        return error_info

    def _get_runtime_suggestion(self, error_info: Dict) -> str:
        """获取运行时错误建议"""
        message = error_info.get('message', '').lower()

        suggestions = {
            'nameerror': "检查变量名是否正确，确保在使用前已定义",
            'typeerror': "检查数据类型是否匹配，确保操作适用于该类型",
            'valueerror': "检查值是否在有效范围内",
            'indexerror': "检查索引是否在有效范围内",
            'keyerror': "检查字典键是否存在",
            'attributeerror': "检查对象是否具有该属性或方法",
            'zerodivisionerror': "检查除数是否为零"
        }

        for error_type, suggestion in suggestions.items():
            if error_type in message:
                return suggestion

        return "请检查错误信息和代码逻辑"

class LogicErrorDetector:
    """逻辑错误检测器"""

    def __init__(self, llm_client: LLMClient):
        self.llm_client = llm_client

    async def detect(self, code: str,
                     execution_result: ExecutionResult = None) -> List[DetectedError]:
        """检测逻辑错误"""
        errors = []

        # 使用 LLM 分析代码逻辑
        prompt = f"""
        分析以下代码中的潜在逻辑错误：

        {code}

        请识别：
        1. 无限循环
        2. 空指针引用
        3. 边界条件错误
        4. 逻辑矛盾
        5. 死代码

        以 JSON 格式返回检测到的错误列表。
        """

        response = await self.llm_client.complete(prompt)
        detected_errors = self._parse_logic_errors(response)

        for error in detected_errors:
            detected_error = DetectedError(
                type='logic',
                severity='medium',
                location=error.get('location', 'Unknown'),
                message=error.get('message', 'Logic error'),
                code_snippet=error.get('code_snippet', ''),
                suggestion=error.get('suggestion', 'Review the logic')
            )
            errors.append(detected_error)

        return errors

    def _parse_logic_errors(self, response: str) -> List[Dict]:
        """解析逻辑错误"""
        try:
            return json.loads(response)
        except json.JSONDecodeError:
            return []

```## 29.5.3 根因分析

### 根因分析器

class RootCauseAnalyzer:
"""根因分析器"""
def __init__(self, llm_client: LLMClient):
self.llm_client = llm_client
async def analyze(self, error: DetectedError,
code: str,
context: Dict = None) -> RootCauseAnalysis:
"""分析根因"""
analysis = RootCauseAnalysis(error=error)
# 收集相关信息
relevant_code = self._collect_relevant_code(error, code)
# 分析根本原因
analysis.root_cause = await self._identify_root_cause(
error,
relevant_code,
context
)
# 分析影响范围
analysis.impact = await self._analyze_impact(
error,
relevant_code
)
# 分析修复难度
analysis.difficulty = await self._estimate_difficulty(
error,
analysis.root_cause
)
return analysis
def _collect_relevant_code(self, error: DetectedError,
code: str) -> str:
"""收集相关代码"""
lines = code.split('\n')
# 提取错误位置周围的代码
if error.location:
try:
line_no = int(error.location.split(',')[0].split()[-1])
start = max(0, line_no - 5)
end = min(len(lines), line_no + 5)
return '\n'.join(lines[start:end])
except (ValueError, IndexError):
pass
return code
async def _identify_root_cause(self, error: DetectedError,
relevant_code: str,
context: Dict) -> str:
"""识别根本原因"""
prompt = f"""
分析错误的根本原因：
错误类型：{error.type}
错误信息：{error.message}
错误位置：{error.location}
相关代码：
{relevant_code}
上下文：{context}
请分析并说明：
1. 错误的根本原因
2. 为什么会发生这个错误
3. 代码中的具体问题
"""
return await self.llm_client.complete(prompt)
async def _analyze_impact(self, error: DetectedError,
relevant_code: str) -> ImpactAnalysis:
"""分析影响范围"""
prompt = f"""
分析错误的影响范围：
错误：{error.message}
相关代码：
{relevant_code}
请分析：
1. 错误影响哪些功能
2. 影响的严重程度
3. 是否会影响其他代码
4. 是否会影响数据完整性
"""
response = await self.llm_client.complete(prompt)
return self._parse_impact(response)
async def _estimate_difficulty(self, error: DetectedError,
root_cause: str) -> str:
"""估计修复难度"""
prompt = f"""
估计修复错误的难度：
错误：{error.message}
根本原因：{root_cause}
请评估修复难度（简单/中等/困难）并说明理由。
"""
return await self.llm_client.complete(prompt)

29.5.4 修复建议#

修复建议生成器#

```python

class FixSuggestionGenerator:
    """修复建议生成器"""

    def __init__(self, llm_client: LLMClient):
        self.llm_client = llm_client

    async def generate_suggestions(self,
                                   analysis: RootCauseAnalysis,
                                   code: str) -> List[FixSuggestion]:
        """生成修复建议"""
        suggestions = []

        # 生成多个修复方案
        prompt = f"""
        为以下错误生成修复建议：

        错误：{analysis.error.message}
        根本原因：{analysis.root_cause}
        原始代码：
        {code}

        请生成 2-3 个不同的修复方案，每个方案包括：
        1. 修复方法
        2. 修改后的代码
        3. 优缺点分析
        4. 适用场景

        以 JSON 格式返回修复方案列表。
        """

        response = await self.llm_client.complete(prompt)
        fix_suggestions = self._parse_fix_suggestions(response)

        for suggestion in fix_suggestions:
            fix_suggestion = FixSuggestion(
                method=suggestion.get('method', ''),
                fixed_code=suggestion.get('fixed_code', ''),
                advantages=suggestion.get('advantages', []),
                disadvantages=suggestion.get('disadvantages', []),
                applicable_scenarios=suggestion.get('applicable_scenarios', ''),
                confidence=suggestion.get('confidence', 0.5)
            )
            suggestions.append(fix_suggestion)

        # 按置信度排序
        suggestions.sort(key=lambda s: s.confidence, reverse=True)

        return suggestions

```## 29.5.5 性能优化

### 性能分析器

class PerformanceAnalyzer:
"""性能分析器"""
def __init__(self, llm_client: LLMClient):
self.llm_client = llm_client
async def analyze(self, code: str,
execution_result: ExecutionResult = None) -> PerformanceAnalysis:

"""分析性能""" analysis = PerformanceAnalysis()

分析时间复杂度

analysis.time_complexity = await self._analyze_time_complexity(code)

分析空间复杂度

analysis.space_complexity = await self._analyze_space_complexity(code)

识别性能瓶颈

analysis.bottlenecks = await self._identify_bottlenecks(code)

生成优化建议

analysis.optimization_suggestions = await self._generate_optimization_suggestions( code, analysis ) return analysis async def _analyze_time_complexity(self, code: str) -> str: """分析时间复杂度""" prompt = f""" 分析以下代码的时间复杂度： {code} 请分析并说明：

1. 整体时间复杂度
2. 关键部分的复杂度
3. 影响复杂度的主要因素 """ return await self.llm_client.complete(prompt) async def _analyze_space_complexity(self, code: str) -> str: """分析空间复杂度""" prompt = f""" 分析以下代码的空间复杂度： {code} 请分析并说明：
4. 整体空间复杂度
5. 内存使用情况
6. 可能的内存泄漏 """ return await self.llm_client.complete(prompt) async def _identify_bottlenecks(self, code: str) -> List[PerformanceBottleneck]: """识别性能瓶颈""" prompt = f""" 识别以下代码中的性能瓶颈： {code} 请识别：
7. 循环嵌套
8. 重复计算
9. 不必要的内存分配
10. 低效的数据结构使用
11. I/O 操作 以 JSON 格式返回瓶颈列表。 """ response = await self.llm_client.complete(prompt) return self._parse_bottlenecks(response) async def _generate_optimization_suggestions(self, code: str, analysis: PerformanceAnalysis) -> List[OptimizationSuggestion]: """生成优化建议""" suggestions = [] for bottleneck in analysis.bottlenecks: prompt = f""" 为以下性能瓶颈生成优化建议： 瓶颈类型：{bottleneck.type} 瓶颈位置：{bottleneck.location} 瓶颈描述：{bottleneck.description} 请生成具体的优化建议，包括：
12. 优化方法
13. 优化后的代码
14. 预期性能提升 """ response = await self.llm_client.complete(prompt) suggestion = OptimizationSuggestion( bottleneck_type=bottleneck.type, method=self._extract_method(response), optimized_code=self._extract_code(response), expected_improvement=self._extract_improvement(response) ) suggestions.append(suggestion) return suggestions

上一页29.4 代码理解模块

下一页29.6 集成与部署