代码 Agent

代码 Agent 是目前最成熟的 Agent 应用场景。从 GitHub Copilot 到 Cursor，代码 Agent 在理解、生成、调试和重构代码方面展现出强大能力。

代码 Agent 能力谱

代码 Agent 架构

"""
代码 Agent 系统
"""
from dataclasses import dataclass, field
from enum import Enum
from abc import ABC, abstractmethod
import ast
class TaskType(Enum):
GENERATE = "generate"
EXPLAIN = "explain"
DEBUG = "debug"
REFACTOR = "refactor"
TEST = "test"
@dataclass
class CodeContext:
"""代码上下文"""
file_path: str
language: str
content: str
cursor_line: int | None = None
selected_range: tuple[int, int] | None = None
diagnostics: list[dict] = field(default_factory=list)  # 编译/lint 错误
@dataclass
class CodeAction:
"""代码操作"""
task_type: TaskType
instruction: str
context: CodeContext
additional_files: list[CodeContext] = field(default_factory=list)
@dataclass
class CodeResult:
"""操作结果"""
code: str
explanation: str
changes: list[dict] = field(default_factory=list)
confidence: float = 0.0
class CodeTool(ABC):
"""代码工具基类"""
@abstractmethod
def execute(self, context: CodeContext, params: dict) -> str:
pass
class ASTAnalyzer(CodeTool):
"""AST 分析工具"""
def execute(self, context: CodeContext, params: dict) -> str:
if context.language != "python":
return "仅支持 Python AST 分析"
try:
tree = ast.parse(context.content)
except SyntaxError as e:
return f"语法错误: {e}"
analysis = {
"functions": [],
"classes": [],
"imports": [],
}
for node in ast.walk(tree):
if isinstance(node, ast.FunctionDef):
analysis["functions"].append({
"name": node.name,
"line": node.lineno,
"args": [a.arg for a in node.args.args],
"decorators": [
getattr(d, "id", str(d)) for d in node.decorator_list
],
})
elif isinstance(node, ast.ClassDef):
methods = [
n.name for n in node.body if isinstance(n, ast.FunctionDef)
]
analysis["classes"].append({
"name": node.name,
"line": node.lineno,
"methods": methods,
})
elif isinstance(node, ast.Import):
analysis["imports"].extend(alias.name for alias in node.names)
elif isinstance(node, ast.ImportFrom):
if node.module:
analysis["imports"].append(node.module)
return str(analysis)
class DependencyAnalyzer(CodeTool):
"""依赖分析工具"""
def execute(self, context: CodeContext, params: dict) -> str:
imports = set()
for line in context.content.split("\n"):
stripped = line.strip()
if stripped.startswith("import "):
module = stripped.split()[1].split(".")[0]
imports.add(module)
elif stripped.startswith("from "):
module = stripped.split()[1].split(".")[0]
imports.add(module)
stdlib = {"os", "sys", "json", "re", "math", "datetime", "pathlib", "typing"}
third_party = imports - stdlib
return str({
"stdlib": sorted(imports & stdlib),
"third_party": sorted(third_party),
})
class CodeAgent:
"""代码 Agent"""
def __init__(self, llm_client):
self.llm = llm_client
self.tools: dict[str, CodeTool] = {
"ast_analyze": ASTAnalyzer(),
"dep_analyze": DependencyAnalyzer(),
}
def handle(self, action: CodeAction) -> CodeResult:
"""处理代码操作"""
if action.task_type == TaskType.DEBUG:
return self._debug(action)
elif action.task_type == TaskType.EXPLAIN:
return self._explain(action)
elif action.task_type == TaskType.GENERATE:
return self._generate(action)
elif action.task_type == TaskType.REFACTOR:
return self._refactor(action)
elif action.task_type == TaskType.TEST:
return self._generate_tests(action)
else:
return CodeResult(code="", explanation="不支持的操作类型", confidence=0.0)
def _debug(self, action: CodeAction) -> CodeResult:
"""调试：分析错误并修复"""
ctx = action.context
# Step 1: AST 分析
ast_info = self.tools["ast_analyze"].execute(ctx, {})
# Step 2: 结合诊断信息
diagnostics = "\n".join(
f"- L{d['line']}: {d['message']}" for d in ctx.diagnostics
)
# Step 3: LLM 修复
prompt = (
f"修复以下 {ctx.language} 代码中的错误。\n\n"
f"文件：{ctx.file_path}\n"
f"代码：\n```\n{ctx.content}\n```\n"
f"诊断信息：\n{diagnostics}\n"
f"AST 分析：{ast_info}\n\n"
f"只输出修复后的完整代码和修改说明。"
)
result = self.llm.generate(prompt)
return CodeResult(
code=result,
explanation="基于诊断信息和 AST 分析进行修复",
confidence=0.8,
)
def _explain(self, action: CodeAction) -> CodeResult:
"""解释代码"""
ctx = action.context
code = ctx.content
if ctx.selected_range:
lines = code.split("\n")
start, end = ctx.selected_range
code = "\n".join(lines[start:end])
prompt = f"用简洁的中文解释以下代码的功能和逻辑：\n```{ctx.language}\n{code}\n```"
explanation = self.llm.generate(prompt)
return CodeResult(code="", explanation=explanation, confidence=0.9)
def _generate(self, action: CodeAction) -> CodeResult:
"""生成代码"""
prompt = (
f"根据以下要求生成 {action.context.language} 代码：\n"
f"{action.instruction}\n\n"
f"现有代码上下文：\n```\n{action.context.content[:500]}\n```"
)
code = self.llm.generate(prompt)
return CodeResult(code=code, explanation="根据指令生成", confidence=0.75)
def _refactor(self, action: CodeAction) -> CodeResult:
"""重构代码"""
deps = self.tools["dep_analyze"].execute(action.context, {})
prompt = (
f"重构以下代码，目标：{action.instruction}\n"
f"依赖分析：{deps}\n"
f"```{action.context.language}\n{action.context.content}\n```"
)
code = self.llm.generate(prompt)
return CodeResult(code=code, explanation="重构完成", confidence=0.7)
def _generate_tests(self, action: CodeAction) -> CodeResult:
"""生成测试"""
ast_info = self.tools["ast_analyze"].execute(action.context, {})
prompt = (
f"为以下代码生成 pytest 测试：\n"
f"AST 分析：{ast_info}\n"
f"```{action.context.language}\n{action.context.content}\n```"
)
tests = self.llm.generate(prompt)
return CodeResult(code=tests, explanation="测试代码已生成", confidence=0.7)

代码 Agent 工具对比

本章小结

下一章：多模态 Agent