代码生成技能概述#
代码生成技能是 Claude Code Skills 中最常用和最强大的类型之一。它可以根据需求自动生成各种类型的代码，显著提高开发效率。
技能类型#
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#
bashpytest
'''
bashdef 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 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 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 端点#
python# 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},
bash{"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"])
bash### 3. 生成数据模型 ```python # 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. 可维护性
- 生成清晰的代码
- 添加注释说明
- 提供修改指南