claude-code-templates 1.21.1 → 1.21.2

package/cli-tool/templates/python/examples/flask-app/.claude/commands/blueprint.md

@@ -1,243 +0,0 @@
-# Flask Blueprint Generator
-
-Create organized Flask blueprints for modular application structure.
-
-## Usage
-
-```bash
-# Create a new blueprint
-flask create-blueprint users
-flask create-blueprint api/v1
-```
-
-## Blueprint Structure
-
-Generates a complete blueprint with:
-- Routes and view functions
-- Error handlers
-- Template folder structure
-- Static file organization
-
-## Example Blueprint
-
-```python
-# app/blueprints/users/__init__.py
-from flask import Blueprint
-
-users_bp = Blueprint(
-    'users',
-    __name__,
-    url_prefix='/users',
-    template_folder='templates',
-    static_folder='static'
-)
-
-from . import routes, models
-
-# app/blueprints/users/routes.py
-from flask import render_template, request, redirect, url_for, flash
-from . import users_bp
-from .models import User
-from .forms import UserForm
-
-@users_bp.route('/')
-def index():
-    """List all users."""
-    users = User.query.all()
-    return render_template('users/index.html', users=users)
-
-@users_bp.route('/create', methods=['GET', 'POST'])
-def create():
-    """Create a new user."""
-    form = UserForm()
-    if form.validate_on_submit():
-        user = User(
-            username=form.username.data,
-            email=form.email.data
-        )
-        user.save()
-        flash('User created successfully!', 'success')
-        return redirect(url_for('users.index'))
-    return render_template('users/create.html', form=form)
-
-@users_bp.route('/<int:user_id>')
-def detail(user_id):
-    """Show user details."""
-    user = User.query.get_or_404(user_id)
-    return render_template('users/detail.html', user=user)
-
-@users_bp.route('/<int:user_id>/edit', methods=['GET', 'POST'])
-def edit(user_id):
-    """Edit an existing user."""
-    user = User.query.get_or_404(user_id)
-    form = UserForm(obj=user)
-    if form.validate_on_submit():
-        user.username = form.username.data
-        user.email = form.email.data
-        user.save()
-        flash('User updated successfully!', 'success')
-        return redirect(url_for('users.detail', user_id=user.id))
-    return render_template('users/edit.html', form=form, user=user)
-
-@users_bp.route('/<int:user_id>/delete', methods=['POST'])
-def delete(user_id):
-    """Delete a user."""
-    user = User.query.get_or_404(user_id)
-    user.delete()
-    flash('User deleted successfully!', 'success')
-    return redirect(url_for('users.index'))
-
-# Error handlers
-@users_bp.errorhandler(404)
-def not_found(error):
-    return render_template('users/404.html'), 404
-
-@users_bp.errorhandler(500)
-def internal_error(error):
-    return render_template('users/500.html'), 500
-```
-
-## Blueprint Models
-
-```python
-# app/blueprints/users/models.py
-from app.extensions import db
-from werkzeug.security import generate_password_hash, check_password_hash
-from datetime import datetime
-
-class User(db.Model):
-    """User model."""
-    __tablename__ = 'users'
-    
-    id = db.Column(db.Integer, primary_key=True)
-    username = db.Column(db.String(80), unique=True, nullable=False)
-    email = db.Column(db.String(120), unique=True, nullable=False)
-    password_hash = db.Column(db.String(255), nullable=False)
-    created_at = db.Column(db.DateTime, default=datetime.utcnow)
-    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
-    is_active = db.Column(db.Boolean, default=True)
-    
-    def __repr__(self):
-        return f'<User {self.username}>'
-    
-    def set_password(self, password):
-        """Set password hash."""
-        self.password_hash = generate_password_hash(password)
-    
-    def check_password(self, password):
-        """Check password hash."""
-        return check_password_hash(self.password_hash, password)
-    
-    def save(self):
-        """Save user to database."""
-        db.session.add(self)
-        db.session.commit()
-    
-    def delete(self):
-        """Delete user from database."""
-        db.session.delete(self)
-        db.session.commit()
-    
-    def to_dict(self):
-        """Convert to dictionary."""
-        return {
-            'id': self.id,
-            'username': self.username,
-            'email': self.email,
-            'created_at': self.created_at.isoformat(),
-            'is_active': self.is_active
-        }
-```
-
-## Blueprint Forms
-
-```python
-# app/blueprints/users/forms.py
-from flask_wtf import FlaskForm
-from wtforms import StringField, EmailField, PasswordField, BooleanField
-from wtforms.validators import DataRequired, Email, Length, EqualTo
-from .models import User
-
-class UserForm(FlaskForm):
-    """User creation/edit form."""
-    username = StringField(
-        'Username',
-        validators=[
-            DataRequired(),
-            Length(min=3, max=80)
-        ]
-    )
-    email = EmailField(
-        'Email',
-        validators=[
-            DataRequired(),
-            Email(),
-            Length(max=120)
-        ]
-    )
-    password = PasswordField(
-        'Password',
-        validators=[
-            DataRequired(),
-            Length(min=8)
-        ]
-    )
-    confirm_password = PasswordField(
-        'Confirm Password',
-        validators=[
-            DataRequired(),
-            EqualTo('password', message='Passwords must match')
-        ]
-    )
-    is_active = BooleanField('Active')
-    
-    def validate_username(self, field):
-        """Validate username uniqueness."""
-        if User.query.filter_by(username=field.data).first():
-            raise ValidationError('Username already exists.')
-    
-    def validate_email(self, field):
-        """Validate email uniqueness."""
-        if User.query.filter_by(email=field.data).first():
-            raise ValidationError('Email already registered.')
-```
-
-## Registration in Main App
-
-```python
-# app/__init__.py
-from flask import Flask
-from app.blueprints.users import users_bp
-
-def create_app():
-    app = Flask(__name__)
-    
-    # Register blueprints
-    app.register_blueprint(users_bp)
-    
-    return app
-```
-
-## Template Structure
-
-```
-templates/
-├── base.html
-└── users/
-    ├── index.html
-    ├── create.html
-    ├── detail.html
-    ├── edit.html
-    ├── 404.html
-    └── 500.html
-```
-
-## Best Practices
-
-- Use blueprints to organize related functionality
-- Keep models, forms, and routes in separate files
-- Implement proper error handling
-- Use URL prefixes for namespacing
-- Follow RESTful routing conventions
-- Include comprehensive docstrings
-- Add form validation and CSRF protection

package/cli-tool/templates/python/examples/flask-app/.claude/commands/database.md

@@ -1,410 +0,0 @@
-# Flask Database Management
-
-Complete database setup and management for Flask applications using SQLAlchemy.
-
-## Usage
-
-```bash
-# Initialize database
-flask db init
-
-# Create migration
-flask db migrate -m "Initial migration"
-
-# Apply migrations
-flask db upgrade
-
-# Downgrade migration
-flask db downgrade
-```
-
-## Database Configuration
-
-```python
-# config.py
-import os
-from urllib.parse import quote_plus
-
-class Config:
-    """Base configuration."""
-    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key'
-    SQLALCHEMY_TRACK_MODIFICATIONS = False
-    SQLALCHEMY_RECORD_QUERIES = True
-    
-class DevelopmentConfig(Config):
-    """Development configuration."""
-    DEBUG = True
-    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
-        'sqlite:///app.db'
-        
-class ProductionConfig(Config):
-    """Production configuration."""
-    DEBUG = False
-    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
-        f"postgresql://{os.environ.get('DB_USER')}:{quote_plus(os.environ.get('DB_PASSWORD'))}@" \
-        f"{os.environ.get('DB_HOST')}:{os.environ.get('DB_PORT', '5432')}/{os.environ.get('DB_NAME')}"
-    
-class TestingConfig(Config):
-    """Testing configuration."""
-    TESTING = True
-    SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
-    WTF_CSRF_ENABLED = False
-
-config = {
-    'development': DevelopmentConfig,
-    'production': ProductionConfig,
-    'testing': TestingConfig,
-    'default': DevelopmentConfig
-}
-```
-
-## Database Extensions
-
-```python
-# app/extensions.py
-from flask_sqlalchemy import SQLAlchemy
-from flask_migrate import Migrate
-from flask_login import LoginManager
-from flask_wtf.csrf import CSRFProtect
-from flask_caching import Cache
-from flask_limiter import Limiter
-from flask_limiter.util import get_remote_address
-
-# Initialize extensions
-db = SQLAlchemy()
-migrate = Migrate()
-login_manager = LoginManager()
-csrf = CSRFProtect()
-cache = Cache()
-limiter = Limiter(key_func=get_remote_address)
-
-def init_extensions(app):
-    """Initialize Flask extensions."""
-    db.init_app(app)
-    migrate.init_app(app, db)
-    login_manager.init_app(app)
-    csrf.init_app(app)
-    cache.init_app(app)
-    limiter.init_app(app)
-    
-    # Configure login manager
-    login_manager.login_view = 'auth.login'
-    login_manager.login_message = 'Please log in to access this page.'
-    login_manager.login_message_category = 'info'
-```
-
-## Base Model
-
-```python
-# app/models/base.py
-from app.extensions import db
-from datetime import datetime
-from sqlalchemy.ext.declarative import declared_attr
-
-class TimestampMixin:
-    """Add timestamp fields to model."""
-    created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
-    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
-
-class BaseModel(db.Model, TimestampMixin):
-    """Base model with common functionality."""
-    __abstract__ = True
-    
-    id = db.Column(db.Integer, primary_key=True)
-    
-    @declared_attr
-    def __tablename__(cls):
-        return cls.__name__.lower()
-    
-    def save(self, commit=True):
-        """Save model to database."""
-        db.session.add(self)
-        if commit:
-            db.session.commit()
-        return self
-    
-    def delete(self, commit=True):
-        """Delete model from database."""
-        db.session.delete(self)
-        if commit:
-            db.session.commit()
-    
-    def update(self, **kwargs):
-        """Update model attributes."""
-        for key, value in kwargs.items():
-            if hasattr(self, key):
-                setattr(self, key, value)
-        return self.save()
-    
-    def to_dict(self, exclude=None):
-        """Convert model to dictionary."""
-        exclude = exclude or []
-        return {
-            column.name: getattr(self, column.name)
-            for column in self.__table__.columns
-            if column.name not in exclude
-        }
-    
-    @classmethod
-    def get_or_404(cls, id):
-        """Get model by ID or raise 404."""
-        return cls.query.get_or_404(id)
-    
-    @classmethod
-    def create(cls, **kwargs):
-        """Create new model instance."""
-        instance = cls(**kwargs)
-        return instance.save()
-```
-
-## Example Models
-
-```python
-# app/models/user.py
-from app.extensions import db
-from app.models.base import BaseModel
-from werkzeug.security import generate_password_hash, check_password_hash
-from flask_login import UserMixin
-
-class User(UserMixin, BaseModel):
-    """User model."""
-    __tablename__ = 'users'
-    
-    username = db.Column(db.String(80), unique=True, nullable=False, index=True)
-    email = db.Column(db.String(120), unique=True, nullable=False, index=True)
-    password_hash = db.Column(db.String(255), nullable=False)
-    first_name = db.Column(db.String(50), nullable=False)
-    last_name = db.Column(db.String(50), nullable=False)
-    is_active = db.Column(db.Boolean, default=True, nullable=False)
-    is_admin = db.Column(db.Boolean, default=False, nullable=False)
-    last_login = db.Column(db.DateTime)
-    
-    # Relationships
-    posts = db.relationship('Post', backref='author', lazy='dynamic', cascade='all, delete-orphan')
-    
-    def __repr__(self):
-        return f'<User {self.username}>'
-    
-    def set_password(self, password):
-        """Set password hash."""
-        self.password_hash = generate_password_hash(password)
-    
-    def check_password(self, password):
-        """Check password hash."""
-        return check_password_hash(self.password_hash, password)
-    
-    @property
-    def full_name(self):
-        """Get user's full name."""
-        return f"{self.first_name} {self.last_name}"
-    
-    def to_dict(self, exclude=None):
-        """Convert to dictionary excluding sensitive data."""
-        exclude = exclude or ['password_hash']
-        return super().to_dict(exclude=exclude)
-
-# app/models/post.py
-class Post(BaseModel):
-    """Blog post model."""
-    __tablename__ = 'posts'
-    
-    title = db.Column(db.String(200), nullable=False)
-    content = db.Column(db.Text, nullable=False)
-    slug = db.Column(db.String(200), unique=True, nullable=False, index=True)
-    status = db.Column(db.String(20), default='draft', nullable=False)
-    published_at = db.Column(db.DateTime)
-    
-    # Foreign keys
-    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
-    category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
-    
-    # Relationships
-    category = db.relationship('Category', backref='posts')
-    tags = db.relationship('Tag', secondary='post_tags', backref='posts')
-    
-    def __repr__(self):
-        return f'<Post {self.title}>'
-    
-    @property
-    def is_published(self):
-        """Check if post is published."""
-        return self.status == 'published' and self.published_at is not None
-```
-
-## Database CLI Commands
-
-```python
-# app/cli.py
-import click
-from flask import current_app
-from flask.cli import with_appcontext
-from app.extensions import db
-from app.models import User, Post, Category
-
-@click.command()
-@with_appcontext
-def init_db():
-    """Initialize database."""
-    db.create_all()
-    click.echo('Database initialized.')
-
-@click.command()
-@with_appcontext
-def seed_db():
-    """Seed database with sample data."""
-    # Create admin user
-    admin = User(
-        username='admin',
-        email='admin@example.com',
-        first_name='Admin',
-        last_name='User',
-        is_admin=True
-    )
-    admin.set_password('admin123')
-    admin.save()
-    
-    # Create sample category
-    category = Category(
-        name='Technology',
-        description='Tech-related posts'
-    )
-    category.save()
-    
-    # Create sample post
-    post = Post(
-        title='Welcome to Flask',
-        content='This is a sample blog post.',
-        slug='welcome-to-flask',
-        status='published',
-        user_id=admin.id,
-        category_id=category.id
-    )
-    post.save()
-    
-    click.echo('Database seeded with sample data.')
-
-@click.command()
-@with_appcontext
-def reset_db():
-    """Reset database."""
-    if click.confirm('Are you sure you want to reset the database?'):
-        db.drop_all()
-        db.create_all()
-        click.echo('Database reset.')
-
-def init_commands(app):
-    """Register CLI commands."""
-    app.cli.add_command(init_db)
-    app.cli.add_command(seed_db)
-    app.cli.add_command(reset_db)
-```
-
-## Connection Pooling
-
-```python
-# app/database.py
-from sqlalchemy import create_engine
-from sqlalchemy.pool import QueuePool
-
-def configure_database(app):
-    """Configure database with connection pooling."""
-    if app.config.get('SQLALCHEMY_DATABASE_URI', '').startswith('postgresql'):
-        # PostgreSQL configuration
-        engine = create_engine(
-            app.config['SQLALCHEMY_DATABASE_URI'],
-            poolclass=QueuePool,
-            pool_size=10,
-            max_overflow=20,
-            pool_recycle=3600,
-            pool_pre_ping=True
-        )
-        app.config['SQLALCHEMY_ENGINE_OPTIONS'] = {
-            'pool_size': 10,
-            'max_overflow': 20,
-            'pool_recycle': 3600,
-            'pool_pre_ping': True
-        }
-```
-
-## Database Utilities
-
-```python
-# app/utils/database.py
-from app.extensions import db
-from sqlalchemy import text
-from flask import current_app
-
-def execute_sql(sql, params=None):
-    """Execute raw SQL query."""
-    with db.engine.connect() as conn:
-        result = conn.execute(text(sql), params or {})
-        return result.fetchall()
-
-def backup_database():
-    """Create database backup."""
-    # Implementation depends on database type
-    pass
-
-def check_database_health():
-    """Check database connection health."""
-    try:
-        db.session.execute(text('SELECT 1'))
-        return True
-    except Exception as e:
-        current_app.logger.error(f'Database health check failed: {e}')
-        return False
-
-def get_table_info(table_name):
-    """Get table information."""
-    inspector = db.inspect(db.engine)
-    return {
-        'columns': inspector.get_columns(table_name),
-        'indexes': inspector.get_indexes(table_name),
-        'foreign_keys': inspector.get_foreign_keys(table_name)
-    }
-```
-
-## Testing Database
-
-```python
-# tests/conftest.py
-import pytest
-from app import create_app
-from app.extensions import db
-from app.models import User
-
-@pytest.fixture(scope='session')
-def app():
-    """Create test app."""
-    app = create_app('testing')
-    with app.app_context():
-        db.create_all()
-        yield app
-        db.drop_all()
-
-@pytest.fixture
-def client(app):
-    """Create test client."""
-    return app.test_client()
-
-@pytest.fixture
-def db_session(app):
-    """Create database session for testing."""
-    with app.app_context():
-        db.session.begin()
-        yield db.session
-        db.session.rollback()
-
-@pytest.fixture
-def user(db_session):
-    """Create test user."""
-    user = User(
-        username='testuser',
-        email='test@example.com',
-        first_name='Test',
-        last_name='User'
-    )
-    user.set_password('testpass')
-    user.save()
-    return user
-```