Claude Code 工作流自动化：5 个让开发效率翻倍的实战技巧

{
  "hooks": {
    "pre-edit": [
      {
        "matcher": "**/*.py",
        "command": "python -m py_compile $FILE && echo 'PASS: syntax ok'"
      },
      {
        "matcher": "**/*.{ts,tsx}",
        "command": "npx eslint --no-warn-ignored $FILE 2>&1 | head -20"
      }
    ],
    "post-edit": [
      {
        "matcher": "**/*.py",
        "command": "python -m pytest tests/ -x -q --tb=short 2>&1 | tail -10"
      }
    ]
  }
}

#!/usr/bin/env python3
"""claude_pre_commit_hook.py - Claude Code 提交前自动检查"""

import subprocess
import sys
from pathlib import Path

def check_python_syntax(filepath: str) -> bool:
    """检查 Python 文件语法"""
    result = subprocess.run(
        ["python", "-m", "py_compile", filepath],
        capture_output=True, text=True
    )
    if result.returncode != 0:
        print(f"SYNTAX ERROR in {filepath}:")
        print(result.stderr)
        return False
    return True

def check_security_issues(filepath: str) -> bool:
    """基础安全检查：检测硬编码密码和危险调用"""
    dangerous_patterns = [
        ("password =", "可能包含硬编码密码"),
        ("eval(", "使用了危险的 eval() 调用"),
        ("exec(", "使用了危险的 exec() 调用"),
        ("subprocess.call(shell=True)", "shell=True 存在命令注入风险"),
        ("pickle.loads(", "反序列化不受信任的数据"),
    ]
    content = Path(filepath).read_text(encoding="utf-8", errors="ignore")
    issues = []
    for pattern, desc in dangerous_patterns:
        if pattern in content:
            # 跳过注释和字符串中的匹配
            for i, line in enumerate(content.splitlines(), 1):
                stripped = line.strip()
                if stripped.startswith("#") or stripped.startswith('"""') or stripped.startswith("'''"):
                    continue
                if pattern in line:
                    issues.append(f"  行 {i}: {desc} — {pattern}")
    if issues:
        print(f"SECURITY WARNING in {filepath}:")
        for issue in issues:
            print(issue)
    return len(issues) == 0

def check_import_order(filepath: str) -> bool:
    """检查 import 顺序：stdlib -> third-party -> local"""
    if not filepath.endswith(".py"):
        return True
    content = Path(filepath).read_text(encoding="utf-8", errors="ignore")
    lines = content.splitlines()
    
    stdlib_done = False
    third_party_done = False
    
    stdlib_prefixes = ("os", "sys", "json", "re", "time", "datetime", "pathlib",
                       "collections", "itertools", "functools", "typing", "dataclasses",
                       "hashlib", "base64", "io", "subprocess", "threading", "logging")
    
    for line in lines:
        if not line.startswith("import ") and not line.startswith("from "):
            continue
        if line.startswith("from .") or line.startswith("from .."):
            if not third_party_done:
                print(f"IMPORT ORDER: 本地导入出现在第三方导入之前: {line.strip()}")
                return False
            continue
        
        module = line.split()[1].split(".")[0]
        if module in stdlib_prefixes:
            if third_party_done:
                print(f"IMPORT ORDER: 标准库导入出现在第三方导入之后: {line.strip()}")
                return False
        else:
            stdlib_done = True
    
    return True

def main():
    if len(sys.argv) < 2:
        print("Usage: claude_pre_commit_hook.py <filepath>")
        sys.exit(1)
    
    filepath = sys.argv[1]
    all_passed = True
    
    if filepath.endswith(".py"):
        all_passed &= check_python_syntax(filepath)
        all_passed &= check_security_issues(filepath)
        all_passed &= check_import_order(filepath)
    elif filepath.endswith((".ts", ".tsx")):
        result = subprocess.run(
            ["npx", "eslint", "--no-warn-ignored", filepath],
            capture_output=True, text=True
        )
        if result.returncode != 0:
            print(f"LINT ERROR in {filepath}:")
            print(result.stdout[:500])
            all_passed = False
    
    if all_passed:
        print(f"ALL CHECKS PASSED for {filepath}")
    sys.exit(0 if all_passed else 1)

if __name__ == "__main__":
    main()

{
  "hooks": {
    "pre-edit": [
      {
        "matcher": "**/*.{py,ts,tsx}",
        "command": "python .claude/claude_pre_commit_hook.py $FILE"
      }
    ]
  }
}

将 app.js 中的所有路由重构为模块化结构：
1. 创建 routes/ 目录
2. 将 /api/users 相关路由提取到 routes/users.js
3. 将 /api/posts 相关路由提取到 routes/posts.js
4. 将 /api/auth 相关路由提取到 routes/auth.js
5. 每个路由文件导出 Router 实例
6. 在 app.js 中通过 app.use() 挂载
7. 保持所有中间件和验证逻辑不变

# 项目规范

## 技术栈
- 后端：Python 3.11 + FastAPI
- 前端：Vue 3 + TypeScript + Pinia
- 数据库：PostgreSQL 16
- 缓存：Redis 7

## 代码规范
- Python 遵循 PEP 8，使用 Ruff 格式化
- TypeScript 使用 4 空格缩进，分号可选
- API 响应统一格式：`{ code: number, data: T, message: string }`
- 错误处理使用自定义异常类，不使用裸 except
- 数据库操作使用 SQLAlchemy 异步 Session

## 目录结构
- src/api/ — FastAPI 路由
- src/models/ — SQLAlchemy 模型
- src/schemas/ — Pydantic 请求/响应模型
- src/services/ — 业务逻辑层
- src/utils/ — 工具函数
- tests/ — 测试文件

## 测试要求
- 新增 API 必须包含至少 3 个测试用例（正常、边界、异常）
- 使用 pytest + httpx AsyncClient

name: Claude Code Auto Review
on:
  pull_request:
    types: [opened, synchronize]
    branches: [main, develop]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Run Claude Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          CLAUDE_CODE=1 claude --dangerously-skip-permissions \
            "审查这个 PR 的所有变更文件，重点关注：
            1. 安全漏洞（SQL注入、XSS、硬编码密钥）
            2. 性能问题（N+1查询、不必要的循环）
            3. 错误处理遗漏
            4. 代码风格一致性
            请用中文输出审查意见，每个问题标注严重程度[高/中/低]和具体文件行号" \
            --output-format json > review_result.json

      - name: Post Review Comment
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          python3 .claude/format_review.py review_result.json

#!/usr/bin/env python3
"""format_review.py - 将 Claude Code 审查结果格式化为 GitHub PR 评论"""

import json
import os
import subprocess
import sys

def format_review(json_path: str) -> str:
    """读取审查结果并格式化"""
    with open(json_path) as f:
        data = json.load(f)
    
    review_text = data.get("text", "")
    
    # 构建评论体
    comment = f"""## 🤖 Claude Code 自动审查报告

<details>
<summary>点击展开详细审查意见</summary>

{review_text}

</details>

---
*此评论由 Claude Code 自动生成，仅供参考。请结合人工审查做出最终判断。*
"""
    return comment

def post_to_github(comment: str):
    """通过 GitHub CLI 发布 PR 评论"""
    pr_number = os.environ.get("GITHUB_PR_NUMBER", "")
    if not pr_number:
        # 尝试从 git 获取 PR 编号
        result = subprocess.run(
            ["gh", "pr", "view", "--json", "number", "-q", ".number"],
            capture_output=True, text=True
        )
        pr_number = result.stdout.strip()
    
    if pr_number:
        # 写入临时文件避免命令行转义问题
        with open("/tmp/claude_review_comment.md", "w") as f:
            f.write(comment)
        subprocess.run([
            "gh", "pr", "comment", pr_number,
            "--body-file", "/tmp/claude_review_comment.md"
        ])
        print(f"Review comment posted to PR #{pr_number}")
    else:
        print("Could not determine PR number, outputting review:")
        print(comment)

if __name__ == "__main__":
    json_path = sys.argv[1] if len(sys.argv) > 1 else "review_result.json"
    comment = format_review(json_path)
    post_to_github(comment)

#!/usr/bin/env python3
"""project_tools_mcp.py - 项目管理 MCP Server

让 Claude Code 能够：
- 查询项目依赖版本
- 读取数据库 schema
- 执行预定义的数据库查询
- 生成 API 文档
"""

import asyncio
import json
import subprocess
from pathlib import Path
from typing import Any

# MCP 协议基础实现
class MCPServer:
    def __init__(self, project_root: str):
        self.project_root = Path(project_root)
        self.tools = self._register_tools()
    
    def _register_tools(self) -> dict:
        return {
            "get_project_deps": {
                "description": "获取项目的依赖列表及版本信息",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "package_file": {
                            "type": "string",
                            "enum": ["package.json", "requirements.txt", "pyproject.toml"],
                            "description": "依赖配置文件"
                        }
                    },
                    "required": ["package_file"]
                },
                "handler": self._get_project_deps
            },
            "get_db_schema": {
                "description": "获取数据库表结构信息",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "table_name": {
                            "type": "string",
                            "description": "表名，留空则返回所有表"
                        }
                    }
                },
                "handler": self._get_db_schema
            },
            "run_safe_query": {
                "description": "执行只读 SQL 查询（仅允许 SELECT）",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "sql": {
                            "type": "string",
                            "description": "SELECT 查询语句"
                        },
                        "limit": {
                            "type": "integer",
                            "description": "最大返回行数，默认 50",
                            "default": 50
                        }
                    },
                    "required": ["sql"]
                },
                "handler": self._run_safe_query
            },
            "generate_api_docs": {
                "description": "根据路由文件自动生成 API 文档",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "route_dir": {
                            "type": "string",
                            "description": "路由文件目录，默认 src/api",
                            "default": "src/api"
                        }
                    }
                },
                "handler": self._generate_api_docs
            }
        }
    
    def _get_project_deps(self, args: dict) -> str:
        """读取项目依赖"""
        filename = args["package_file"]
        filepath = self.project_root / filename
        if not filepath.exists():
            return json.dumps({"error": f"{filename} not found"})
        
        content = filepath.read_text()
        deps = []
        
        if filename == "package.json":
            pkg = json.loads(content)
            all_deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
            deps = [{"name": k, "version": v} for k, v in all_deps.items()]
        elif filename == "requirements.txt":
            for line in content.splitlines():
                line = line.strip()
                if line and not line.startswith("#"):
                    parts = line.split("==") if "==" in line else line.split(">=") if ">=" in line else line.split("~=")
                    name = parts[0].strip()
                    version = parts[1].strip() if len(parts) > 1 else "latest"
                    deps.append({"name": name, "version": version})
        
        return json.dumps({"dependencies": deps}, ensure_ascii=False, indent=2)
    
    def _get_db_schema(self, args: dict) -> str:
        """获取数据库 schema（示例实现）"""
        table_name = args.get("table_name", "")
        # 实际项目中替换为真实数据库查询
        schema = {
            "tables": [
                {
                    "name": "users",
                    "columns": [
                        {"name": "id", "type": "SERIAL PRIMARY KEY"},
                        {"name": "username", "type": "VARCHAR(50) UNIQUE NOT NULL"},
                        {"name": "email", "type": "VARCHAR(100) UNIQUE NOT NULL"},
                        {"name": "created_at", "type": "TIMESTAMP DEFAULT NOW()"}
                    ]
                },
                {
                    "name": "posts",
                    "columns": [
                        {"name": "id", "type": "SERIAL PRIMARY KEY"},
                        {"name": "user_id", "type": "INTEGER REFERENCES users(id)"},
                        {"name": "title", "type": "VARCHAR(200) NOT NULL"},
                        {"name": "content", "type": "TEXT"},
                        {"name": "published", "type": "BOOLEAN DEFAULT false"},
                        {"name": "created_at", "type": "TIMESTAMP DEFAULT NOW()"}
                    ]
                }
            ]
        }
        if table_name:
            schema["tables"] = [t for t in schema["tables"] if t["name"] == table_name]
        return json.dumps(schema, ensure_ascii=False, indent=2)
    
    def _run_safe_query(self, args: dict) -> str:
        """安全执行只读查询"""
        sql = args["sql"].strip()
        if not sql.upper().startswith("SELECT"):
            return json.dumps({"error": "Only SELECT queries are allowed"})
        
        limit = args.get("limit", 50)
        if "LIMIT" not in sql.upper():
            sql += f" LIMIT {limit}"
        
        # 实际项目中使用 asyncpg 或 psycopg2 执行
        return json.dumps({
            "sql": sql,
            "message": "Query prepared (replace with actual DB connection)",
            "result": []
        })
    
    def _generate_api_docs(self, args: dict) -> str:
        """自动生成 API 文档"""
        route_dir = self.project_root / args.get("route_dir", "src/api")
        if not route_dir.exists():
            return json.dumps({"error": f"Route directory {route_dir} not found"})
        
        endpoints = []
        for py_file in route_dir.glob("**/*.py"):
            if py_file.name.startswith("_"):
                continue
            content = py_file.read_text(errors="ignore")
            # 简单解析装饰器中的路由信息
            import re
            routes = re.findall(r'@router\.(get|post|put|delete|patch)\s*\(\s*"([^"]+)"', content)
            for method, path in routes:
                endpoints.append({
                    "file": str(py_file.relative_to(self.project_root)),
                    "method": method.upper(),
                    "path": path,
                })
        
        return json.dumps({"endpoints": endpoints}, ensure_ascii=False, indent=2)

# 启动 MCP Server (简化版，实际需实现 stdio 通信)
if __name__ == "__main__":
    import sys
    server = MCPServer(project_root=".")
    print(json.dumps({
        "name": "project-tools",
        "version": "1.0.0",
        "tools": list(server.tools.keys())
    }, indent=2))

{
  "mcpServers": {
    "project-tools": {
      "command": "python3",
      "args": ["/path/to/project/.claude/project_tools_mcp.py"],
      "cwd": "/path/to/project"
    }
  }
}

#!/usr/bin/env python3
"""generate_claude_context.py - 为 Claude Code 生成项目上下文摘要"""

import os
from pathlib import Path
from collections import defaultdict

def scan_project(root: str) -> dict:
    """扫描项目结构，生成上下文索引"""
    root_path = Path(root)
    context = {
        "structure": {},
        "entry_points": [],
        "important_files": [],
        "tech_stack": set(),
    }
    
    # 跳过的目录
    skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "dist", "build",
                 ".next", ".nuxt", "coverage", ".mypy_cache", ".pytest_cache"}
    
    file_stats = defaultdict(list)
    
    for filepath in root_path.rglob("*"):
        if not filepath.is_file():
            continue
        if any(skip in filepath.parts for skip in skip_dirs):
            continue
        
        rel_path = str(filepath.relative_to(root_path))
        ext = filepath.suffix
        file_stats[ext].append(rel_path)
        
        # 识别入口文件
        if filepath.name in ("main.py", "app.py", "index.ts", "index.js", "server.py"):
            context["entry_points"].append(rel_path)
        
        # 识别配置文件
        if filepath.name in ("package.json", "pyproject.toml", "requirements.txt",
                             "tsconfig.json", "Dockerfile", "docker-compose.yml"):
            context["important_files"].append(rel_path)
    
    # 识别技术栈
    if file_stats.get(".py"):
        context["tech_stack"].add("Python")
    if file_stats.get(".ts") or file_stats.get(".tsx"):
        context["tech_stack"].add("TypeScript")
    if file_stats.get(".vue"):
        context["tech_stack"].add("Vue")
    if file_stats.get(".jsx"):
        context["tech_stack"].add("React")
    if "package.json" in str(context["important_files"]):
        context["tech_stack"].add("Node.js")
    
    context["structure"] = dict(file_stats)
    context["tech_stack"] = sorted(context["tech_stack"])
    
    return context

def generate_claude_md(context: dict, output_path: str = "CLAUDE.md"):
    """生成 CLAUDE.md 文件"""
    lines = ["# 项目上下文（自动生成）", ""]
    
    lines.append("## 技术栈")
    lines.append(", ".join(context["tech_stack"]))
    lines.append("")
    
    lines.append("## 入口文件")
    for ep in context["entry_points"]:
        lines.append(f"- {ep}")
    lines.append("")
    
    lines.append("## 重要配置")
    for f in context["important_files"]:
        lines.append(f"- {f}")
    lines.append("")
    
    lines.append("## 文件统计")
    for ext, files in sorted(context["structure"].items()):
        lines.append(f"- {ext or '(无扩展名)'}: {len(files)} 个文件")
    lines.append("")
    
    lines.append("## 目录概览")
    for ext, files in sorted(context["structure"].items()):
        lines.append(f"\n### {ext or '其他'} 文件")
        for f in sorted(files)[:20]:  # 每类最多显示20个
            lines.append(f"- {f}")
        if len(files) > 20:
            lines.append(f"- ... 还有 {len(files) - 20} 个文件")
    
    Path(output_path).write_text("\n".join(lines), encoding="utf-8")
    print(f"Generated {output_path}")

if __name__ == "__main__":
    import sys
    root = sys.argv[1] if len(sys.argv) > 1 else "."
    ctx = scan_project(root)
    generate_claude_md(ctx)

@src/models/user.py @src/schemas/user.py 
在这个用户模型中添加一个「最后登录时间」字段，同时更新对应的 Pydantic schema，
确保数据库迁移脚本和 API 响应都保持一致