AI 原生编程工具 2026：Claude Code、Cursor、Codex 与软件开发范式的根本性转移

# 1. 直接在终端启动 Claude Code
$ claude

# 2. 给出自然语言需求
> 帮我重构这个项目的数据库层：把所有 SQLAlchemy 查询迁移到异步模式，
  更新所有相关的测试用例，确保向后兼容

# 3. Claude Code 自主执行：
#    - 扫描项目结构，识别所有数据库相关文件
#    - 分析现有同步查询模式
#    - 制定迁移计划
#    - 逐个文件修改
#    - 运行测试验证
#    - 提交 git commit

# 4. 审核结果
> 让我看看你改了哪些文件
# Claude Code 展示 diff 摘要

# 5. 确认提交
> 看起来没问题，提交吧
# Claude Code 执行 git commit

"""
AI 编程助手核心引擎 —— 基于 MCP 协议的自定义 Coding Agent
演示如何用最少的代码构建一个具有自主编程能力的 AI Agent
"""
import json
import subprocess
import os
from typing import Any
from pathlib import Path

# ============= 工具定义层 =============
# 每个工具都遵循 MCP 标准接口

class FileTool:
    """文件读写工具 - AI Agent 的眼睛和手"""
    
    name = "file_operations"
    description = "Read and write files in the project"
    
    @staticmethod
    def read_file(path: str, max_lines: int = 200) -> str:
        """读取文件内容，带行数标记"""
        try:
            file_path = Path(path)
            if not file_path.exists():
                return f"Error: File not found: {path}"
            lines = file_path.read_text().split('\n')
            if max_lines and len(lines) > max_lines:
                lines = lines[:max_lines]
                lines.append(f"... ({len(lines)} more lines)")
            return '\n'.join(f"{i+1}: {line}" for i, line in enumerate(lines))
        except Exception as e:
            return f"Error reading {path}: {str(e)}"
    
    @staticmethod
    def write_file(path: str, content: str) -> str:
        """写入文件，自动创建父目录"""
        try:
            file_path = Path(path)
            file_path.parent.mkdir(parents=True, exist_ok=True)
            file_path.write_text(content)
            return f"Successfully wrote {len(content)} chars to {path}"
        except Exception as e:
            return f"Error writing {path}: {str(e)}"
    
    @staticmethod
    def list_directory(path: str = ".") -> str:
        """列出目录结构"""
        try:
            items = []
            for item in sorted(Path(path).iterdir()):
                prefix = "📁" if item.is_dir() else "📄"
                items.append(f"{prefix} {item.name}")
            return '\n'.join(items)
        except Exception as e:
            return f"Error listing {path}: {str(e)}"


class SearchTool:
    """代码搜索工具 - 让 AI 理解你的代码库"""
    
    name = "code_search"
    description = "Search code in the project"
    
    @staticmethod
    def grep(pattern: str, directory: str = ".", file_pattern: str = "*.py") -> str:
        """在项目中搜索代码"""
        try:
            cmd = f"grep -rn '{pattern}' --include='{file_pattern}' {directory}"
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            if result.returncode == 0:
                lines = result.stdout.strip().split('\n')
                return '\n'.join(lines[:50])  # 限制输出长度
            return f"No matches found for '{pattern}'"
        except Exception as e:
            return f"Search error: {str(e)}"
    
    @staticmethod
    def find_files(pattern: str, directory: str = ".") -> str:
        """查找匹配的文件"""
        try:
            cmd = f"find {directory} -name '{pattern}' -type f"
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
            return result.stdout.strip() if result.stdout else "No files found"
        except Exception as e:
            return f"Find error: {str(e)}"


class ShellTool:
    """终端命令工具 - 赋予 AI 执行能力"""
    
    name = "shell"
    description = "Execute shell commands"
    
    @staticmethod
    def execute(command: str, timeout: int = 30) -> str:
        """执行终端命令"""
        # 安全白名单机制
        blocked_commands = ["rm -rf /", "mkfs", "dd if=", ":(){ :|:;& };"]
        for blocked in blocked_commands:
            if blocked in command:
                return f"Error: Dangerous command blocked: {blocked}"
        
        try:
            result = subprocess.run(
                command, shell=True, capture_output=True,
                text=True, timeout=timeout, cwd=os.getcwd()
            )
            output = result.stdout
            if result.stderr:
                output += f"\nSTDERR: {result.stderr}"
            return output[:5000]  # 限制输出长度
        except subprocess.TimeoutExpired:
            return f"Error: Command timed out after {timeout}s"
        except Exception as e:
            return f"Execution error: {str(e)}"


# ============= Agent 核心引擎 =============

class CodingAgent:
    """AI 编程 Agent 核心 - 意图理解 → 工具调用 → 结果验证 循环"""
    
    def __init__(self, tools: list):
        self.tools = {t.name: t for t in tools}
        self.history = []
        self.tool_registry = self._build_tool_registry()
    
    def _build_tool_registry(self) -> list[dict]:
        """构建 MCP 风格的工具注册表"""
        registry = []
        for name, tool in self.tools.items():
            registry.append({
                "name": name,
                "description": tool.description,
                "methods": [
                    m for m in dir(tool)
                    if not m.startswith('_') and callable(getattr(tool, m))
                ]
            })
        return registry
    
    def analyze_intent(self, user_input: str) -> dict:
        """分析用户意图（简化版，实际应调用 LLM）"""
        intent = {
            "type": "unknown",
            "target": None,
            "action": None,
        }
        
        input_lower = user_input.lower()
        
        # 简单的意图分类
        if any(w in input_lower for w in ["读", "查看", "read", "show", "看"]):
            intent["type"] = "read"
            intent["action"] = "read_file"
        elif any(w in input_lower for w in ["写", "创建", "create", "write", "生成"]):
            intent["type"] = "write"
            intent["action"] = "write_file"
        elif any(w in input_lower for w in ["搜", "search", "find", "找", "grep"]):
            intent["type"] = "search"
            intent["action"] = "grep"
        elif any(w in input_lower for w in ["执行", "run", "list", "ls", "列出"]):
            intent["type"] = "execute"
            intent["action"] = "shell"
        
        # 提取文件路径
        import re
        path_match = re.findall(r'[\w./-]+\.(py|js|ts|md|json|yaml|yml|toml|cfg)', user_input)
        if path_match:
            intent["target"] = path_match[0]
        
        return intent
    
    def execute(self, intent: dict) -> str:
        """根据意图执行工具调用"""
        action = intent["action"]
        
        if action == "read_file" and intent.get("target"):
            return self.tools["file_operations"].read_file(intent["target"])
        elif action == "write_file":
            # 简化：实际应从 LLM 获取内容
            return "Write requires content from LLM"
        elif action == "grep":
            return self.tools["code_search"].grep("TODO")
        elif action == "shell":
            return self.tools["shell"].execute("ls -la")
        
        return f"Unknown action: {action}"
    
    def run(self, user_input: str) -> str:
        """完整的 Agent 循环"""
        # Step 1: 记录历史
        self.history.append({"role": "user", "content": user_input})
        
        # Step 2: 意图分析
        intent = self.analyze_intent(user_input)
        
        # Step 3: 工具执行
        result = self.execute(intent)
        
        # Step 4: 记录结果
        self.history.append({
            "role": "assistant",
            "intent": intent,
            "result": result
        })
        
        return result


# ============= 使用示例 =============

if __name__ == "__main__":
    # 创建 Agent 实例
    agent = CodingAgent([
        FileTool(),
        SearchTool(),
        ShellTool(),
    ])
    
    # 展示可用工具
    print("🤖 可用工具:")
    for tool in agent.tool_registry:
        print(f"  - {tool['name']}: {tool['description']}")
        print(f"    方法: {', '.join(tool['methods'])}")
    
    # 测试 Agent 循环
    print("\n" + "="*50)
    
    test_inputs = [
        "帮我读一下 config.py 文件",
        "搜索项目中所有的 TODO",
        "列出当前目录的文件",
    ]
    
    for user_input in test_inputs:
        print(f"\n👤 用户: {user_input}")
        result = agent.run(user_input)
        print(f"🤖 Agent: {result[:200]}...")