claude-code-templates 1.0.2 → 1.1.0

package/templates/python/.claude/commands/flask-route.md

@@ -0,0 +1,217 @@
+# Flask Route Generator
+
+Create Flask routes with proper structure and error handling.
+
+## Purpose
+
+This command helps you quickly create Flask routes with validation, error handling, and best practices.
+
+## Usage
+
+```
+/flask-route
+```
+
+## What this command does
+
+1. **Creates route functions** with proper decorators
+2. **Adds request validation** and error handling
+3. **Includes JSON responses** and status codes
+4. **Implements authentication** if needed
+5. **Follows Flask conventions** and best practices
+
+## Example Output
+
+```python
+# routes.py or app.py
+from flask import Flask, request, jsonify, abort
+from flask_sqlalchemy import SQLAlchemy
+from werkzeug.exceptions import BadRequest
+
+app = Flask(__name__)
+
+@app.route('/users', methods=['GET'])
+def get_users():
+    """Get all users with optional pagination."""
+    try:
+        page = request.args.get('page', 1, type=int)
+        per_page = request.args.get('per_page', 10, type=int)
+        
+        users = User.query.paginate(
+            page=page, 
+            per_page=per_page, 
+            error_out=False
+        )
+        
+        return jsonify({
+            'users': [user.to_dict() for user in users.items],
+            'total': users.total,
+            'pages': users.pages,
+            'current_page': page
+        }), 200
+        
+    except Exception as e:
+        return jsonify({'error': 'Failed to fetch users'}), 500
+
+@app.route('/users/<int:user_id>', methods=['GET'])
+def get_user(user_id):
+    """Get a specific user by ID."""
+    try:
+        user = User.query.get_or_404(user_id)
+        return jsonify(user.to_dict()), 200
+        
+    except Exception as e:
+        return jsonify({'error': 'User not found'}), 404
+
+@app.route('/users', methods=['POST'])
+def create_user():
+    """Create a new user."""
+    try:
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({'error': 'No data provided'}), 400
+        
+        # Validate required fields
+        required_fields = ['name', 'email']
+        for field in required_fields:
+            if field not in data:
+                return jsonify({'error': f'{field} is required'}), 400
+        
+        # Check if email already exists
+        if User.query.filter_by(email=data['email']).first():
+            return jsonify({'error': 'Email already exists'}), 409
+        
+        # Create new user
+        user = User(
+            name=data['name'],
+            email=data['email'],
+            phone=data.get('phone'),
+            address=data.get('address')
+        )
+        
+        db.session.add(user)
+        db.session.commit()
+        
+        return jsonify(user.to_dict()), 201
+        
+    except BadRequest:
+        return jsonify({'error': 'Invalid JSON data'}), 400
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': 'Failed to create user'}), 500
+
+@app.route('/users/<int:user_id>', methods=['PUT'])
+def update_user(user_id):
+    """Update an existing user."""
+    try:
+        user = User.query.get_or_404(user_id)
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({'error': 'No data provided'}), 400
+        
+        # Update fields
+        if 'name' in data:
+            user.name = data['name']
+        if 'email' in data:
+            # Check if new email already exists
+            existing_user = User.query.filter_by(email=data['email']).first()
+            if existing_user and existing_user.id != user_id:
+                return jsonify({'error': 'Email already exists'}), 409
+            user.email = data['email']
+        if 'phone' in data:
+            user.phone = data['phone']
+        if 'address' in data:
+            user.address = data['address']
+        
+        db.session.commit()
+        
+        return jsonify(user.to_dict()), 200
+        
+    except BadRequest:
+        return jsonify({'error': 'Invalid JSON data'}), 400
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': 'Failed to update user'}), 500
+
+@app.route('/users/<int:user_id>', methods=['DELETE'])
+def delete_user(user_id):
+    """Delete a user."""
+    try:
+        user = User.query.get_or_404(user_id)
+        
+        db.session.delete(user)
+        db.session.commit()
+        
+        return jsonify({'message': 'User deleted successfully'}), 200
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': 'Failed to delete user'}), 500
+
+# Error handlers
+@app.errorhandler(404)
+def not_found(error):
+    return jsonify({'error': 'Resource not found'}), 404
+
+@app.errorhandler(400)
+def bad_request(error):
+    return jsonify({'error': 'Bad request'}), 400
+
+@app.errorhandler(500)
+def internal_error(error):
+    return jsonify({'error': 'Internal server error'}), 500
+```
+
+## Route Patterns Supported
+
+### Basic Routes
+```python
+@app.route('/')
+@app.route('/users')
+@app.route('/users/<int:user_id>')
+```
+
+### HTTP Methods
+```python
+@app.route('/users', methods=['GET', 'POST'])
+@app.route('/users/<int:id>', methods=['GET', 'PUT', 'DELETE'])
+```
+
+### URL Parameters
+```python
+@app.route('/users/<int:user_id>')
+@app.route('/posts/<string:slug>')
+@app.route('/files/<path:filename>')
+```
+
+## Best Practices Included
+
+- **Input validation** for all user data
+- **Proper HTTP status codes** (200, 201, 400, 404, 500)
+- **JSON responses** with consistent structure
+- **Error handling** with try/catch blocks
+- **Database rollback** on errors
+- **RESTful conventions** for URL design
+- **Documentation strings** for each route
+- **Request data validation** before processing
+
+## Common Response Patterns
+
+```python
+# Success with data
+return jsonify({'data': result}), 200
+
+# Created resource
+return jsonify({'data': new_resource, 'id': new_id}), 201
+
+# Validation error
+return jsonify({'error': 'Field is required'}), 400
+
+# Not found
+return jsonify({'error': 'Resource not found'}), 404
+
+# Server error
+return jsonify({'error': 'Internal server error'}), 500
+```

package/templates/python/.claude/commands/lint.md

@@ -0,0 +1,111 @@
+# Python Linter
+
+Run Python code linting and formatting tools.
+
+## Purpose
+
+This command helps you maintain code quality using Python's best linting and formatting tools.
+
+## Usage
+
+```
+/lint
+```
+
+## What this command does
+
+1. **Runs multiple linters** (flake8, pylint, black, isort)
+2. **Provides detailed feedback** on code quality issues
+3. **Auto-fixes formatting** where possible
+4. **Checks type hints** if mypy is configured
+
+## Example Commands
+
+### Black (code formatting)
+```bash
+# Format all Python files
+black .
+
+# Check formatting without changing files
+black --check .
+
+# Format specific file
+black src/main.py
+```
+
+### flake8 (style guide enforcement)
+```bash
+# Check all Python files
+flake8 .
+
+# Check specific directory
+flake8 src/
+
+# Check with specific rules
+flake8 --max-line-length=88 .
+```
+
+### isort (import sorting)
+```bash
+# Sort imports in all files
+isort .
+
+# Check import sorting
+isort --check-only .
+
+# Sort imports in specific file
+isort src/main.py
+```
+
+### pylint (comprehensive linting)
+```bash
+# Run pylint on all files
+pylint src/
+
+# Run with specific score threshold
+pylint --fail-under=8.0 src/
+
+# Generate detailed report
+pylint --output-format=html src/ > pylint_report.html
+```
+
+### mypy (type checking)
+```bash
+# Check types in all files
+mypy .
+
+# Check specific module
+mypy src/models.py
+
+# Check with strict mode
+mypy --strict src/
+```
+
+## Configuration Files
+
+Most projects benefit from configuration files:
+
+### .flake8
+```ini
+[flake8]
+max-line-length = 88
+exclude = .git,__pycache__,venv
+ignore = E203,W503
+```
+
+### pyproject.toml
+```toml
+[tool.black]
+line-length = 88
+
+[tool.isort]
+profile = "black"
+```
+
+## Best Practices
+
+- Run linters before committing code
+- Use consistent formatting across the project
+- Fix linting issues promptly
+- Configure linters to match your team's style
+- Use type hints for better code documentation

package/templates/python/.claude/commands/test.md

@@ -0,0 +1,73 @@
+# Test Runner
+
+Run Python tests with pytest, unittest, or other testing frameworks.
+
+## Purpose
+
+This command helps you run Python tests effectively with proper configuration and reporting.
+
+## Usage
+
+```
+/test
+```
+
+## What this command does
+
+1. **Detects test framework** (pytest, unittest, nose2)
+2. **Runs appropriate tests** with proper configuration
+3. **Provides coverage reporting** if available
+4. **Shows clear test results** with failure details
+
+## Example Commands
+
+### pytest (recommended)
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=src --cov-report=html
+
+# Run specific test file
+pytest tests/test_models.py
+
+# Run with verbose output
+pytest -v
+
+# Run tests matching pattern
+pytest -k "test_user"
+```
+
+### unittest
+```bash
+# Run all tests
+python -m unittest discover
+
+# Run specific test file
+python -m unittest tests.test_models
+
+# Run with verbose output
+python -m unittest -v
+```
+
+### Django tests
+```bash
+# Run all Django tests
+python manage.py test
+
+# Run specific app tests
+python manage.py test myapp
+
+# Run with coverage
+coverage run --source='.' manage.py test
+coverage report
+```
+
+## Best Practices
+
+- Write tests for all critical functionality
+- Use descriptive test names
+- Keep tests isolated and independent
+- Mock external dependencies
+- Aim for high test coverage (80%+)