claude-code-templates 1.2.0 → 1.3.0

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

@@ -1,217 +0,0 @@
-# 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

@@ -1,111 +0,0 @@
-# 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

@@ -1,73 +0,0 @@
-# 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%+)

package/templates/python/CLAUDE.md

@@ -1,276 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-This is a Python project optimized for modern Python development. The project uses industry-standard tools and follows best practices for scalable application development.
-
-## Development Commands
-
-### Environment Management
-- `python -m venv venv` - Create virtual environment
-- `source venv/bin/activate` (Linux/Mac) or `venv\Scripts\activate` (Windows) - Activate virtual environment
-- `deactivate` - Deactivate virtual environment
-- `pip install -r requirements.txt` - Install dependencies
-- `pip install -r requirements-dev.txt` - Install development dependencies
-
-### Package Management
-- `pip install <package>` - Install a package
-- `pip install -e .` - Install project in development mode
-- `pip freeze > requirements.txt` - Generate requirements file
-- `pip-tools compile requirements.in` - Compile requirements with pip-tools
-
-### Testing Commands
-- `pytest` - Run all tests
-- `pytest -v` - Run tests with verbose output
-- `pytest --cov` - Run tests with coverage report
-- `pytest --cov-report=html` - Generate HTML coverage report
-- `pytest -x` - Stop on first failure
-- `pytest -k "test_name"` - Run specific test by name
-- `python -m unittest` - Run tests with unittest
-
-### Code Quality Commands
-- `black .` - Format code with Black
-- `black --check .` - Check code formatting without changes
-- `isort .` - Sort imports
-- `isort --check-only .` - Check import sorting
-- `flake8` - Run linting with Flake8
-- `pylint src/` - Run linting with Pylint
-- `mypy src/` - Run type checking with MyPy
-
-### Development Tools
-- `python -m pip install --upgrade pip` - Upgrade pip
-- `python -c "import sys; print(sys.version)"` - Check Python version
-- `python -m site` - Show Python site information
-- `python -m pdb script.py` - Debug with pdb
-
-## Technology Stack
-
-### Core Technologies
-- **Python** - Primary programming language (3.8+)
-- **pip** - Package management
-- **venv** - Virtual environment management
-
-### Common Frameworks
-- **Django** - High-level web framework
-- **Flask** - Micro web framework
-- **FastAPI** - Modern API framework with automatic documentation
-- **SQLAlchemy** - SQL toolkit and ORM
-- **Pydantic** - Data validation using Python type hints
-
-### Data Science & ML
-- **NumPy** - Numerical computing
-- **Pandas** - Data manipulation and analysis
-- **Matplotlib/Seaborn** - Data visualization
-- **Scikit-learn** - Machine learning library
-- **TensorFlow/PyTorch** - Deep learning frameworks
-
-### Testing Frameworks
-- **pytest** - Testing framework
-- **unittest** - Built-in testing framework
-- **pytest-cov** - Coverage plugin for pytest
-- **factory-boy** - Test fixtures
-- **responses** - Mock HTTP requests
-
-### Code Quality Tools
-- **Black** - Code formatter
-- **isort** - Import sorter
-- **flake8** - Style guide enforcement
-- **pylint** - Code analysis
-- **mypy** - Static type checker
-- **pre-commit** - Git hooks framework
-
-## Project Structure Guidelines
-
-### File Organization
-```
-src/
-├── package_name/
-│   ├── __init__.py
-│   ├── main.py          # Application entry point
-│   ├── models/          # Data models
-│   ├── views/           # Web views (Django/Flask)
-│   ├── api/             # API endpoints
-│   ├── services/        # Business logic
-│   ├── utils/           # Utility functions
-│   └── config/          # Configuration files
-tests/
-├── __init__.py
-├── conftest.py          # pytest configuration
-├── test_models.py
-├── test_views.py
-└── test_utils.py
-requirements/
-├── base.txt            # Base requirements
-├── dev.txt             # Development requirements
-└── prod.txt            # Production requirements
-```
-
-### Naming Conventions
-- **Files/Modules**: Use snake_case (`user_profile.py`)
-- **Classes**: Use PascalCase (`UserProfile`)
-- **Functions/Variables**: Use snake_case (`get_user_data`)
-- **Constants**: Use UPPER_SNAKE_CASE (`API_BASE_URL`)
-- **Private methods**: Prefix with underscore (`_private_method`)
-
-## Python Guidelines
-
-### Type Hints
-- Use type hints for function parameters and return values
-- Import types from `typing` module when needed
-- Use `Optional` for nullable values
-- Use `Union` for multiple possible types
-- Document complex types with comments
-
-### Code Style
-- Follow PEP 8 style guide
-- Use meaningful variable and function names
-- Keep functions focused and single-purpose
-- Use docstrings for modules, classes, and functions
-- Limit line length to 88 characters (Black default)
-
-### Best Practices
-- Use list comprehensions for simple transformations
-- Prefer `pathlib` over `os.path` for file operations
-- Use context managers (`with` statements) for resource management
-- Handle exceptions appropriately with try/except blocks
-- Use `logging` module instead of print statements
-
-## Testing Standards
-
-### Test Structure
-- Organize tests to mirror source code structure
-- Use descriptive test names that explain the behavior
-- Follow AAA pattern (Arrange, Act, Assert)
-- Use fixtures for common test data
-- Group related tests in classes
-
-### Coverage Goals
-- Aim for 90%+ test coverage
-- Write unit tests for business logic
-- Use integration tests for external dependencies
-- Mock external services in tests
-- Test error conditions and edge cases
-
-### pytest Configuration
-```python
-# pytest.ini or pyproject.toml
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-python_files = ["test_*.py", "*_test.py"]
-python_classes = ["Test*"]
-python_functions = ["test_*"]
-addopts = "--cov=src --cov-report=term-missing"
-```
-
-## Virtual Environment Setup
-
-### Creation and Activation
-```bash
-# Create virtual environment
-python -m venv venv
-
-# Activate (Linux/Mac)
-source venv/bin/activate
-
-# Activate (Windows)
-venv\Scripts\activate
-
-# Install dependencies
-pip install -r requirements.txt
-pip install -r requirements-dev.txt
-```
-
-### Requirements Management
-- Use `requirements.txt` for production dependencies
-- Use `requirements-dev.txt` for development dependencies
-- Consider using `pip-tools` for dependency resolution
-- Pin versions for reproducible builds
-
-## Django-Specific Guidelines
-
-### Project Structure
-```
-project_name/
-├── manage.py
-├── project_name/
-│   ├── __init__.py
-│   ├── settings/
-│   ├── urls.py
-│   └── wsgi.py
-├── apps/
-│   ├── users/
-│   ├── products/
-│   └── orders/
-└── requirements/
-```
-
-### Common Commands
-- `python manage.py runserver` - Start development server
-- `python manage.py migrate` - Apply database migrations
-- `python manage.py makemigrations` - Create new migrations
-- `python manage.py createsuperuser` - Create admin user
-- `python manage.py collectstatic` - Collect static files
-- `python manage.py test` - Run Django tests
-
-## FastAPI-Specific Guidelines
-
-### Project Structure
-```
-src/
-├── main.py              # FastAPI application
-├── api/
-│   ├── __init__.py
-│   ├── dependencies.py  # Dependency injection
-│   └── v1/
-│       ├── __init__.py
-│       └── endpoints/
-├── core/
-│   ├── __init__.py
-│   ├── config.py       # Settings
-│   └── security.py    # Authentication
-├── models/
-├── schemas/            # Pydantic models
-└── services/
-```
-
-### Common Commands
-- `uvicorn main:app --reload` - Start development server
-- `uvicorn main:app --host 0.0.0.0 --port 8000` - Start production server
-
-## Security Guidelines
-
-### Dependencies
-- Regularly update dependencies with `pip list --outdated`
-- Use `safety` package to check for known vulnerabilities
-- Pin dependency versions in requirements files
-- Use virtual environments to isolate dependencies
-
-### Code Security
-- Validate input data with Pydantic or similar
-- Use environment variables for sensitive configuration
-- Implement proper authentication and authorization
-- Sanitize data before database operations
-- Use HTTPS for production deployments
-
-## Development Workflow
-
-### Before Starting
-1. Check Python version compatibility
-2. Create and activate virtual environment
-3. Install dependencies from requirements files
-4. Run type checking with `mypy`
-
-### During Development
-1. Use type hints for better code documentation
-2. Run tests frequently to catch issues early
-3. Use meaningful commit messages
-4. Format code with Black before committing
-
-### Before Committing
-1. Run full test suite: `pytest`
-2. Check code formatting: `black --check .`
-3. Sort imports: `isort --check-only .`
-4. Run linting: `flake8`
-5. Run type checking: `mypy src/`

package/templates/rust/README.md

@@ -1,26 +0,0 @@
-# Rust Claude Code Templates
-
-## Coming Soon! 🚧
-
-We're actively working on creating comprehensive Claude Code templates for Rust development.
-
-### What to Expect
-- Best practices for Rust project structure
-- Integration with popular Rust tools and frameworks
-- Workflow optimizations for Rust development
-- Testing and benchmarking configurations
-- Cross-compilation and deployment setups
-- Memory safety and performance guidelines
-
-### Meanwhile...
-You can use the [common templates](../common/README.md) as a starting point for your Rust projects. The universal guidelines and git workflows will work well with Rust development.
-
-### Stay Updated
-⭐ Star this repository to get notified when the Rust templates are released!
-
-### Contributing
-Interested in helping build these templates? We welcome contributions! Please check the main repository's contribution guidelines and feel free to open an issue or pull request.
-
----
-
-*Expected release: Coming soon*