18.1 程式碼生成技能
程式碼生成技能概述
程式碼生成技能是 Claude Code Skills 中最常用和最強大的型別之一。它可以根據需求自動生成各種型別的程式碼，顯著提高開發效率。
python
## 技能类型
### 1\. 模板代码生成
#### 1.1 项目模板生成
python
# src/skills/project_template_generator.py
from typing import Dict, Any
from claude_code_sdk import Skill, SkillContext, SkillResult
class ProjectTemplateGeneratorSkill(Skill):
"""项目模板生成技能"""
def __init__(self):
super().__init__(
name="project-template-generator",
version="1.0.0",
description="Generate project templates"
)
def get_parameters_schema(self) -> Dict[str, Any]:
return {
"type": "object",
"properties": {
"project_type": {
"type": "string",
"enum": ["web-app", "cli-tool", "library", "microservice"],
"description": "Type of project to generate"
},
"language": {
"type": "string",
"enum": ["python", "javascript", "java", "go"],
"description": "Programming language"
},
"framework": {
"type": "string",
"description": "Framework to use"
},
"project_name": {
"type": "string",
"description": "Name of the project"
},
"output_dir": {
"type": "string",
"description": "Output directory"
}
},
"required": ["project_type", "language", "project_name"]
}
def execute(self, parameters: Dict[str, Any], context: SkillContext) -> SkillResult:
try:
project_type = parameters["project_type"]
language = parameters["language"]
project_name = parameters["project_name"]
framework = parameters.get("framework")
output_dir = parameters.get("output_dir", ".")
# 生成项目结构
structure = self.generate_structure(
project_type, language, framework, project_name
)
# 创建文件
created_files = []
for file_path, content in structure.items():
full_path = context.join_path(output_dir, file_path)
context.write_file(full_path, content)
created_files.append(full_path)
return SkillResult(
success=True,
data={
"project_name": project_name,
"project_type": project_type,
"language": language,
"framework": framework,
"files_created": created_files,
"structure": structure
}
)
except Exception as e:
return SkillResult(
success=False,
error=str(e)
)
def generate_structure(self, project_type: str, language: str,
framework: str, project_name: str) -> Dict[str, str]:
"""生成项目结构"""
generators = {
"web-app": self.generate_web_app,
"cli-tool": self.generate_cli_tool,
"library": self.generate_library,
"microservice": self.generate_microservice
}
generator = generators.get(project_type)
if not generator:
raise ValueError(f"Unsupported project type: {project_type}")
return generator(language, framework, project_name)
def generate_web_app(self, language: str, framework: str,
project_name: str) -> Dict[str, str]:
"""生成 Web 应用项目"""
structure = {}
if language == "python":
structure = self.generate_python_web_app(framework, project_name)
elif language == "javascript":
structure = self.generate_javascript_web_app(framework, project_name)
return structure
def generate_python_web_app(self, framework: str,
project_name: str) -> Dict[str, str]:
"""生成 Python Web 应用"""
structure = {
f"{project_name}/": "",
f"{project_name}/__init__.py": "",
f"{project_name}/app.py": self.generate_flask_app(project_name),
f"{project_name}/requirements.txt": self.generate_requirements(framework),
f"{project_name}/config.py": self.generate_config(),
f"{project_name}/templates/": "",
f"{project_name}/templates/index.html": self.generate_html_template(),
f"{project_name}/static/": "",
f"{project_name}/static/css/": "",
f"{project_name}/static/css/style.css": self.generate_css(),
f"{project_name}/tests/": "",
f"{project_name}/tests/__init__.py": "",
f"{project_name}/tests/test_app.py": self.generate_test_file(),
"README.md": self.generate_readme(project_name),
".gitignore": self.generate_gitignore()
}
return structure
def generate_flask_app(self, project_name: str) -> str:
"""生成 Flask 应用代码"""
return f'''from flask import Flask, render_template, jsonify
app = Flask(__name__)
@app.route('/')
def index():
"""Home page"""
return render_template('index.html')
@app.route('/api/health')
def health():
"""Health check endpoint"""
return jsonify({{"status": "healthy"}})
if __name__ == '__main__':
app.run(debug=True)
'''
def generate_requirements(self, framework: str) -> str:
"""生成 requirements.txt"""
return f'''{framework}>=2.0.0
pytest>=7.0.0
python-dotenv>=0.19.0
'''
def generate_config(self) -> str:
"""生成配置文件"""
return '''import os
class Config:
"""Application configuration"""
SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key')
DEBUG = os.getenv('DEBUG', 'True').lower() == 'true'
'''
def generate_html_template(self) -> str:
"""生成 HTML 模板"""
return '''<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>My App</title>
<link rel="stylesheet" href="/static/css/style.css">
</head>
<body>
<div class="container">
<h1>Welcome to My App</h1>
<p>This is a template for your web application.</p>
</div>
</body>
</html>
'''
def generate_css(self) -> str:
"""生成 CSS 文件"""
return '''body {
font-family: Arial, sans-serif;
margin: 0;
padding: 0;
}
.container {
max-width: 1200px;
margin: 0 auto;
padding: 20px;
}
h1 {
color: #333;
}
'''
def generate_test_file(self) -> str:
"""生成测试文件"""
return '''import pytest
from app import app
@pytest.fixture
def client():
app.config['TESTING'] = True
with app.test_client() as client:
yield client
def test_index(client):
"""Test index page"""
response = client.get('/')
assert response.status_code == 200
def test_health(client):
"""Test health endpoint"""
response = client.get('/api/health')
assert response.status_code == 200
assert response.json['status'] == 'healthy'
'''
def generate_readme(self, project_name: str) -> str:
"""生成 README"""
return f'''# {project_name}
A web application built with Flask.
## Installation
```bash
pip install -r requirements.txt
## Running
bashpython app.py
Testing
bash
pytest
'''
bash
def generate_gitignore(self) -> str:
"""生成 .gitignore"""
return '''__pycache__/
*.py[cod] *$py.class .env .venv/ venv/ '''
bash
### 2. API 端点生成
#### 2.1 REST API 生成
```python
# src/skills/api_generator.py
python
from typing import Dict, Any, List
from claude_code_sdk import Skill, SkillContext, SkillResult
class APIGeneratorSkill(Skill):
"""API 端点生成技能"""
def __init__(self):
super().__init__(
name="api-generator",
version="1.0.0",
description="Generate REST API endpoints from data models"
)
def get_parameters_schema(self) -> Dict[str, Any]:
return {
"type": "object",
"properties": {
"models": {
"type": "array",
"description": "Data models to generate APIs for",
"items": {
"type": "object",
"properties": {
"name": {"type": "string"},
"fields": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {"type": "string"},
"type": {"type": "string"},
"required": {"type": "boolean"}
}
}
}
}
}
},
"framework": {
"type": "string",
"enum": ["flask", "fastapi", "express"],
"description": "Framework to use"
},
"include_crud": {
"type": "boolean",
"description": "Include CRUD operations",
"default": True
}
},
"required": ["models", "framework"]
}
def execute(self, parameters: Dict[str, Any], context: SkillContext) -> SkillResult:
try:
models = parameters["models"]
framework = parameters["framework"]
include_crud = parameters.get("include_crud", True)
# 生成 API 代码
api_code = self.generate_api(models, framework, include_crud)
return SkillResult(
success=True,
data={
"framework": framework,
"models": models,
"include_crud": include_crud,
"api_code": api_code
}
)
except Exception as e:
return SkillResult(
success=False,
error=str(e)
)
def generate_api(self, models: List[Dict], framework: str,
include_crud: bool) -> str:
"""生成 API 代码"""
generators = {
"flask": self.generate_flask_api,
"fastapi": self.generate_fastapi_api,
"express": self.generate_express_api
}
generator = generators.get(framework)
if not generator:
raise ValueError(f"Unsupported framework: {framework}")
return generator(models, include_crud)
def generate_flask_api(self, models: List[Dict], include_crud: bool) -> str:
"""生成 Flask API"""
imports = '''from flask import Flask, request, jsonify
from typing import Dict, Any
'''
app_code = '''
app = Flask(__name__)
# In-memory storage (replace with database in production)
storage = {}
'''
routes = []
for model in models:
model_name = model["name"]
model_name_lower = model_name.lower()
if include_crud:
# CREATE
routes.append(f'''@app.route('/api/{model_name_lower}', methods=['POST'])
def create_{model_name_lower}():
"""Create a new {model_name}"""
data = request.get_json()
{model_name_lower}_id = len(storage.get('{model_name_lower}', [])) + 1
data['id'] = {model_name_lower}_id
if '{model_name_lower}' not in storage:
storage['{model_name_lower}'] = []
storage['{model_name_lower}'].append(data)
return jsonify(data), 201
''')
# READ ALL
routes.append(f'''@app.route('/api/{model_name_lower}', methods=['GET'])
def get_{model_name_lower}s():
"""Get all {model_name}s"""
return jsonify(storage.get('{model_name_lower}', []))
''')
# READ ONE
routes.append(f'''@app.route('/api/{model_name_lower}/<int:{model_name_lower}_id>', methods=['GET'])
def get_{model_name_lower}({model_name_lower}_id):
"""Get a specific {model_name}"""
items = storage.get('{model_name_lower}', [])
item = next((i for i in items if i['id'] == {model_name_lower}_id), None)
if item:
return jsonify(item)
return jsonify({{"error": "{model_name} not found"}}), 404
''')
# UPDATE
routes.append(f'''@app.route('/api/{model_name_lower}/<int:{model_name_lower}_id>', methods=['PUT'])
def update_{model_name_lower}({model_name_lower}_id):
"""Update a {model_name}"""
data = request.get_json()
items = storage.get('{model_name_lower}', [])
item = next((i for i in items if i['id'] == {model_name_lower}_id), None)
if item:
item.update(data)
return jsonify(item)
return jsonify({{"error": "{model_name} not found"}}), 404
''')
# DELETE
routes.append(f'''@app.route('/api/{model_name_lower}/<int:{model_name_lower}_id>', methods=['DELETE'])
def delete_{model_name_lower}({model_name_lower}_id):
"""Delete a {model_name}"""
items = storage.get('{model_name_lower}', [])
item = next((i for i in items if i['id'] == {model_name_lower}_id), None)
if item:
items.remove(item)
return jsonify({{"message": "{model_name} deleted"}})
return jsonify({{"error": "{model_name} not found"}}), 404
''')
main_code = '''
if __name__ == '__main__':
app.run(debug=True)
'''
return imports + app_code + ''.join(routes) + main_code
### 3\. 数据模型生成
#### 3.1 ORM 模型生成
python
# src/skills/model_generator.py
from typing import Dict, Any, List
from claude_code_sdk import Skill, SkillContext, SkillResult
class ModelGeneratorSkill(Skill):
"""数据模型生成技能"""
def __init__(self):
super().__init__(
name="model-generator",
version="1.0.0",
description="Generate ORM models from schema definitions"
)
def get_parameters_schema(self) -> Dict[str, Any]:
return {
"type": "object",
"properties": {
"schema": {
"type": "object",
"description": "Database schema definition"
},
"orm": {
"type": "string",
"enum": ["sqlalchemy", "django", "mongoose"],
"description": "ORM to use"
}
},
"required": ["schema", "orm"]
}
def execute(self, parameters: Dict[str, Any], context: SkillContext) -> SkillResult:
try:
schema = parameters["schema"]
orm = parameters["orm"]
# 生成模型代码
model_code = self.generate_models(schema, orm)
return SkillResult(
success=True,
data={
"orm": orm,
"schema": schema,
"model_code": model_code
}
)
except Exception as e:
return SkillResult(
success=False,
error=str(e)
)
def generate_models(self, schema: Dict, orm: str) -> str:
"""生成模型代码"""
generators = {
"sqlalchemy": self.generate_sqlalchemy_models,
"django": self.generate_django_models,
"mongoose": self.generate_mongoose_models
}
generator = generators.get(orm)
if not generator:
raise ValueError(f"Unsupported ORM: {orm}")
return generator(schema)
def generate_sqlalchemy_models(self, schema: Dict) -> str:
"""生成 SQLAlchemy 模型"""
code = '''from sqlalchemy import Column, Integer, String, Float, DateTime, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from datetime import datetime
Base = declarative_base()
'''
for table_name, table_def in schema.items():
fields = table_def.get("fields", [])
code += f'''class {self.to_camel_case(table_name)}(Base):
"""{table_name} model"""
__tablename__ = '{table_name}'
id = Column(Integer, primary_key=True)
'''
for field in fields:
field_name = field["name"]
field_type = field["type"]
field_required = field.get("required", False)
column_type = self.get_sqlalchemy_type(field_type)
nullable = not field_required
code += f' {field_name} = Column({column_type}, nullable={nullable})\n'
code += '\n'
return code
def get_sqlalchemy_type(self, field_type: str) -> str:
"""获取 SQLAlchemy 类型"""
type_mapping = {
"string": "String(255)",
"text": "String)",
"integer": "Integer",
"float": "Float",
"boolean": "Boolean",
"datetime": "DateTime",
"date": "Date"
}
return type_mapping.get(field_type, "String(255)")
def to_camel_case(self, snake_str: str) -> str:
"""转换为驼峰命名"""
components = snake_str.split('_')
return ''.join(x.title() for x in components)
## 使用示例
### 1. 生成 Web 应用
```python
# examples/generate_web_app.py
```python
from skills.project_template_generator import ProjectTemplateGeneratorSkill
from claude_code_sdk import SkillContext
skill = ProjectTemplateGeneratorSkill()
context = SkillContext()
result = skill.execute(
{
"project_type": "web-app",
"language": "python",
"framework": "flask",
"project_name": "my-web-app",
"output_dir": "./projects"
},
context
)
print(f"Created {len(result.data['files_created'])} files")
for file_path in result.data['files_created']:
print(f" - {file_path}")
### 2\. 生成 API 端点
pythonpython
# examples/generate_api.py
from skills.api_generator import APIGeneratorSkill
from claude_code_sdk import SkillContext
skill = APIGeneratorSkill()
context = SkillContext()
result = skill.execute(
{
"models": [
{
"name": "User",
"fields": [
{"name": "username", "type": "string", "required": True},
{"name": "email", "type": "string", "required": True},
{"name": "age", "type": "integer", "required": False}
]
},
{
"name": "Product",
"fields": [
{"name": "name", "type": "string", "required": True},
{"name": "price", "type": "float", "required": True},
{"name": "description", "type": "text", "required": False}
]
}
],
"framework": "flask",
"include_crud": True
},
context
)
print(result.data["api_code"])
### 3\. 生成数据模型
pythonpython
# examples/generate_models.py
from skills.model_generator import ModelGeneratorSkill
from claude_code_sdk import SkillContext
skill = ModelGeneratorSkill()
context = SkillContext()
result = skill.execute(
{
"schema": {
"users": {
"fields": [
{"name": "username", "type": "string", "required": True},
{"name": "email", "type": "string", "required": True},
{"name": "created_at", "type": "datetime", "required": True}
]
},
"products": {
"fields": [
{"name": "name", "type": "string", "required": True},
{"name": "price", "type": "float", "required": True},
{"name": "stock", "type": "integer", "required": False}
]
}
},
"orm": "sqlalchemy"
},
context
)
print(result.data["model_code"])
## 最佳实践
### 1\. 模板设计
#### 模板设计原则
##### 1\. 可配置性 * 使用引數化模板
* 提供多種選項
* 支援自定義
##### 2\. 可擴充套件性
* 模組化設計
* 易於新增新功能
* 支援外掛機制
##### 3\. 最佳實踐
* 遵循框架規範
* 包含安全措施
* 新增文件註釋
### 2\. 程式碼生成策略
#### 1\. 增量生成
* 只生成必要的檔案
* 避免覆蓋現有程式碼
* 提供合併選項
#### 2\. 程式碼質量
* 遵循編碼規範
* 包含型別註解
* 新增文件字串
#### 3\. 可維護性
* 生成清晰的程式碼
* 新增註釋說明
* 提供修改指南