@malamute/ai-rules 1.0.0 → 1.3.0

package/configs/python/.claude/rules/flask.md

@@ -1,332 +0,0 @@
----
-paths:
-  - "**/*.py"
----
-
-# Flask Rules
-
-## Application Factory
-
-```python
-from flask import Flask
-from flask_sqlalchemy import SQLAlchemy
-from flask_migrate import Migrate
-
-db = SQLAlchemy()
-migrate = Migrate()
-
-def create_app(config_name: str = "development") -> Flask:
-    app = Flask(__name__)
-    app.config.from_object(config[config_name])
-
-    # Initialize extensions
-    db.init_app(app)
-    migrate.init_app(app, db)
-
-    # Register blueprints
-    from app.users import bp as users_bp
-    from app.auth import bp as auth_bp
-
-    app.register_blueprint(users_bp, url_prefix="/api/v1/users")
-    app.register_blueprint(auth_bp, url_prefix="/api/v1/auth")
-
-    # Register error handlers
-    register_error_handlers(app)
-
-    return app
-```
-
-## Blueprints
-
-```python
-from flask import Blueprint, request, jsonify
-from http import HTTPStatus
-
-bp = Blueprint("users", __name__)
-
-@bp.get("/")
-def list_users():
-    """List all users with pagination."""
-    page = request.args.get("page", 1, type=int)
-    per_page = request.args.get("per_page", 20, type=int)
-
-    pagination = User.query.paginate(page=page, per_page=per_page)
-
-    return jsonify({
-        "items": [user.to_dict() for user in pagination.items],
-        "total": pagination.total,
-        "page": pagination.page,
-        "pages": pagination.pages,
-    })
-
-
-@bp.get("/<int:user_id>")
-def get_user(user_id: int):
-    """Get a user by ID."""
-    user = db.get_or_404(User, user_id)
-    return jsonify(user.to_dict())
-
-
-@bp.post("/")
-def create_user():
-    """Create a new user."""
-    data = request.get_json()
-
-    # Validation
-    errors = validate_user_data(data)
-    if errors:
-        return jsonify({"errors": errors}), HTTPStatus.BAD_REQUEST
-
-    user = User(
-        email=data["email"],
-        name=data["name"],
-    )
-    user.set_password(data["password"])
-
-    db.session.add(user)
-    db.session.commit()
-
-    return jsonify(user.to_dict()), HTTPStatus.CREATED
-
-
-@bp.put("/<int:user_id>")
-def update_user(user_id: int):
-    """Update a user."""
-    user = db.get_or_404(User, user_id)
-    data = request.get_json()
-
-    if "email" in data:
-        user.email = data["email"]
-    if "name" in data:
-        user.name = data["name"]
-
-    db.session.commit()
-    return jsonify(user.to_dict())
-
-
-@bp.delete("/<int:user_id>")
-def delete_user(user_id: int):
-    """Delete a user."""
-    user = db.get_or_404(User, user_id)
-    db.session.delete(user)
-    db.session.commit()
-    return "", HTTPStatus.NO_CONTENT
-```
-
-## Models with Flask-SQLAlchemy
-
-```python
-from datetime import datetime
-from werkzeug.security import generate_password_hash, check_password_hash
-from app import db
-
-class TimestampMixin:
-    created_at = db.Column(db.DateTime, default=datetime.utcnow)
-    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
-
-class User(TimestampMixin, db.Model):
-    __tablename__ = "users"
-
-    id = db.Column(db.Integer, primary_key=True)
-    email = db.Column(db.String(256), unique=True, nullable=False, index=True)
-    password_hash = db.Column(db.String(256), nullable=False)
-    name = db.Column(db.String(100))
-    role = db.Column(db.String(50), default="user")
-
-    # Relationships
-    posts = db.relationship("Post", back_populates="author", lazy="dynamic")
-
-    def set_password(self, password: str) -> None:
-        self.password_hash = generate_password_hash(password)
-
-    def check_password(self, password: str) -> bool:
-        return check_password_hash(self.password_hash, password)
-
-    def to_dict(self) -> dict:
-        return {
-            "id": self.id,
-            "email": self.email,
-            "name": self.name,
-            "role": self.role,
-            "created_at": self.created_at.isoformat(),
-        }
-```
-
-## Error Handling
-
-```python
-from flask import jsonify
-from werkzeug.exceptions import HTTPException
-
-def register_error_handlers(app: Flask) -> None:
-
-    @app.errorhandler(HTTPException)
-    def handle_http_exception(error: HTTPException):
-        return jsonify({
-            "error": error.name,
-            "message": error.description,
-        }), error.code
-
-    @app.errorhandler(ValidationError)
-    def handle_validation_error(error: ValidationError):
-        return jsonify({
-            "error": "Validation Error",
-            "message": str(error),
-            "details": error.errors,
-        }), HTTPStatus.BAD_REQUEST
-
-    @app.errorhandler(Exception)
-    def handle_generic_exception(error: Exception):
-        app.logger.exception("Unhandled exception")
-        return jsonify({
-            "error": "Internal Server Error",
-            "message": "An unexpected error occurred",
-        }), HTTPStatus.INTERNAL_SERVER_ERROR
-```
-
-## Authentication with Flask-JWT-Extended
-
-```python
-from flask_jwt_extended import (
-    JWTManager,
-    create_access_token,
-    create_refresh_token,
-    jwt_required,
-    get_jwt_identity,
-    current_user,
-)
-
-jwt = JWTManager()
-
-@jwt.user_identity_loader
-def user_identity_lookup(user: User) -> int:
-    return user.id
-
-@jwt.user_lookup_loader
-def user_lookup_callback(_jwt_header, jwt_data) -> User | None:
-    identity = jwt_data["sub"]
-    return User.query.get(identity)
-
-# Auth blueprint
-auth_bp = Blueprint("auth", __name__)
-
-@auth_bp.post("/login")
-def login():
-    data = request.get_json()
-    user = User.query.filter_by(email=data["email"]).first()
-
-    if not user or not user.check_password(data["password"]):
-        return jsonify({"error": "Invalid credentials"}), HTTPStatus.UNAUTHORIZED
-
-    return jsonify({
-        "access_token": create_access_token(identity=user),
-        "refresh_token": create_refresh_token(identity=user),
-    })
-
-@auth_bp.post("/refresh")
-@jwt_required(refresh=True)
-def refresh():
-    user = current_user
-    return jsonify({
-        "access_token": create_access_token(identity=user),
-    })
-
-# Protected route
-@bp.get("/me")
-@jwt_required()
-def get_current_user():
-    return jsonify(current_user.to_dict())
-```
-
-## Request Validation with Marshmallow
-
-```python
-from marshmallow import Schema, fields, validate, ValidationError, post_load
-
-class UserCreateSchema(Schema):
-    email = fields.Email(required=True)
-    password = fields.Str(required=True, validate=validate.Length(min=8))
-    name = fields.Str(required=True, validate=validate.Length(min=1, max=100))
-
-class UserUpdateSchema(Schema):
-    email = fields.Email()
-    name = fields.Str(validate=validate.Length(max=100))
-
-class UserResponseSchema(Schema):
-    id = fields.Int(dump_only=True)
-    email = fields.Email()
-    name = fields.Str()
-    created_at = fields.DateTime(dump_only=True)
-
-# Usage in route
-@bp.post("/")
-def create_user():
-    schema = UserCreateSchema()
-    try:
-        data = schema.load(request.get_json())
-    except ValidationError as err:
-        return jsonify({"errors": err.messages}), HTTPStatus.BAD_REQUEST
-
-    # Create user...
-```
-
-## Configuration
-
-```python
-import os
-
-class Config:
-    SECRET_KEY = os.environ.get("SECRET_KEY", "dev-secret-key")
-    SQLALCHEMY_TRACK_MODIFICATIONS = False
-    JWT_SECRET_KEY = os.environ.get("JWT_SECRET_KEY", "jwt-secret")
-    JWT_ACCESS_TOKEN_EXPIRES = timedelta(hours=1)
-
-class DevelopmentConfig(Config):
-    DEBUG = True
-    SQLALCHEMY_DATABASE_URI = os.environ.get(
-        "DATABASE_URL", "sqlite:///dev.db"
-    )
-
-class ProductionConfig(Config):
-    DEBUG = False
-    SQLALCHEMY_DATABASE_URI = os.environ["DATABASE_URL"]
-
-class TestingConfig(Config):
-    TESTING = True
-    SQLALCHEMY_DATABASE_URI = "sqlite:///:memory:"
-
-config = {
-    "development": DevelopmentConfig,
-    "production": ProductionConfig,
-    "testing": TestingConfig,
-}
-```
-
-## CLI Commands
-
-```python
-import click
-from flask.cli import with_appcontext
-
-@app.cli.command("seed-db")
-@with_appcontext
-def seed_db():
-    """Seed the database with initial data."""
-    admin = User(email="admin@example.com", name="Admin", role="admin")
-    admin.set_password("admin123")
-    db.session.add(admin)
-    db.session.commit()
-    click.echo("Database seeded!")
-
-@app.cli.command("create-admin")
-@click.argument("email")
-@click.password_option()
-@with_appcontext
-def create_admin(email: str, password: str):
-    """Create an admin user."""
-    user = User(email=email, role="admin")
-    user.set_password(password)
-    db.session.add(user)
-    db.session.commit()
-    click.echo(f"Admin {email} created!")
-```

package/configs/python/.claude/settings.json

@@ -1,18 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(python *)",
-      "Bash(uvicorn *)",
-      "Bash(fastapi *)",
-      "Bash(flask *)",
-      "Bash(pytest *)",
-      "Bash(ruff *)",
-      "Bash(mypy *)",
-      "Bash(alembic *)",
-      "Bash(uv *)",
-      "Bash(poetry *)",
-      "Bash(pip *)"
-    ],
-    "deny": []
-  }
-}

package/configs/python/CLAUDE.md

@@ -1,273 +0,0 @@
-# Python Project Guidelines
-
-@../_shared/CLAUDE.md
-
-## Stack
-
-- Python 3.11+
-- FastAPI or Flask
-- SQLAlchemy 2.0+ (async support)
-- Pydantic v2 for validation
-- pytest for testing
-- uv or poetry for dependency management
-
-## Architecture
-
-### Domain-Based Structure (Recommended for Monoliths)
-
-```
-src/
-├── app/
-│   ├── __init__.py
-│   ├── main.py                    # Application entry point
-│   ├── config.py                  # Settings with pydantic-settings
-│   ├── database.py                # DB session, engine
-│   │
-│   ├── users/                     # Domain module
-│   │   ├── __init__.py
-│   │   ├── router.py              # API endpoints
-│   │   ├── schemas.py             # Pydantic models (request/response)
-│   │   ├── models.py              # SQLAlchemy models
-│   │   ├── service.py             # Business logic
-│   │   ├── repository.py          # Data access
-│   │   ├── dependencies.py        # Route dependencies
-│   │   └── exceptions.py          # Domain exceptions
-│   │
-│   ├── auth/
-│   │   ├── router.py
-│   │   ├── schemas.py
-│   │   ├── service.py
-│   │   ├── jwt.py
-│   │   └── dependencies.py
-│   │
-│   ├── core/                      # Shared utilities
-│   │   ├── __init__.py
-│   │   ├── exceptions.py          # Base exceptions
-│   │   ├── security.py            # Password hashing, etc.
-│   │   └── pagination.py
-│   │
-│   └── common/
-│       ├── models.py              # Base model classes
-│       └── schemas.py             # Shared schemas
-│
-├── tests/
-│   ├── conftest.py
-│   ├── users/
-│   │   ├── test_router.py
-│   │   └── test_service.py
-│   └── auth/
-│
-├── alembic/                       # Migrations
-│   ├── versions/
-│   └── env.py
-│
-├── pyproject.toml
-└── alembic.ini
-```
-
-### File-Type Structure (For Microservices)
-
-```
-src/
-├── app/
-│   ├── main.py
-│   ├── config.py
-│   ├── routers/
-│   │   ├── users.py
-│   │   └── auth.py
-│   ├── schemas/
-│   │   ├── user.py
-│   │   └── auth.py
-│   ├── models/
-│   │   └── user.py
-│   ├── services/
-│   │   └── user_service.py
-│   └── repositories/
-│       └── user_repository.py
-```
-
-## Code Style
-
-### Type Hints (Required)
-
-```python
-# Always use type hints
-def get_user_by_email(email: str) -> User | None:
-    ...
-
-async def create_user(user_data: UserCreate) -> User:
-    ...
-
-# Use modern syntax (Python 3.10+)
-def process_items(items: list[str]) -> dict[str, int]:  # Not List[str]
-    ...
-```
-
-### Naming Conventions
-
-| Element | Convention | Example |
-|---------|------------|---------|
-| Modules | snake_case | `user_service.py` |
-| Classes | PascalCase | `UserService` |
-| Functions | snake_case | `get_user_by_id` |
-| Variables | snake_case | `user_count` |
-| Constants | UPPER_SNAKE | `MAX_RETRY_COUNT` |
-| Private | _prefix | `_internal_method` |
-
-### Async/Await
-
-```python
-# FastAPI is async-first - use async for I/O operations
-async def get_users(db: AsyncSession) -> list[User]:
-    result = await db.execute(select(User))
-    return result.scalars().all()
-
-# Don't mix sync I/O in async functions
-# Bad - blocks event loop
-async def bad_example():
-    time.sleep(1)  # Blocks!
-    requests.get(url)  # Blocks!
-
-# Good - use async versions
-async def good_example():
-    await asyncio.sleep(1)
-    async with httpx.AsyncClient() as client:
-        await client.get(url)
-```
-
-## Commands
-
-```bash
-# Development
-uvicorn app.main:app --reload
-# or
-fastapi dev app/main.py
-
-# Tests
-pytest
-pytest -v --cov=app
-pytest -k "test_users"
-
-# Linting
-ruff check .
-ruff format .
-
-# Type checking
-mypy app/
-
-# Migrations (Alembic)
-alembic revision --autogenerate -m "Add users table"
-alembic upgrade head
-alembic downgrade -1
-```
-
-## Common Patterns
-
-### Pydantic Settings
-
-```python
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-class Settings(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
-        extra="ignore",
-    )
-
-    # Database
-    database_url: str
-
-    # Auth
-    secret_key: str
-    algorithm: str = "HS256"
-    access_token_expire_minutes: int = 30
-
-    # App
-    debug: bool = False
-    api_prefix: str = "/api/v1"
-
-settings = Settings()
-```
-
-### Dependency Injection
-
-```python
-from typing import Annotated
-from fastapi import Depends
-
-# Database session dependency
-async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    async with async_session_maker() as session:
-        try:
-            yield session
-            await session.commit()
-        except Exception:
-            await session.rollback()
-            raise
-
-DbSession = Annotated[AsyncSession, Depends(get_db)]
-
-# Service dependency
-def get_user_service(db: DbSession) -> UserService:
-    return UserService(UserRepository(db))
-
-UserServiceDep = Annotated[UserService, Depends(get_user_service)]
-
-# Usage in router
-@router.get("/{user_id}")
-async def get_user(user_id: int, service: UserServiceDep) -> UserResponse:
-    return await service.get_by_id(user_id)
-```
-
-### Exception Handling
-
-```python
-from fastapi import HTTPException, status
-
-# Domain exceptions
-class UserNotFoundError(Exception):
-    def __init__(self, user_id: int):
-        self.user_id = user_id
-        super().__init__(f"User {user_id} not found")
-
-class EmailAlreadyExistsError(Exception):
-    def __init__(self, email: str):
-        self.email = email
-
-# Global exception handler
-@app.exception_handler(UserNotFoundError)
-async def user_not_found_handler(request: Request, exc: UserNotFoundError):
-    return JSONResponse(
-        status_code=status.HTTP_404_NOT_FOUND,
-        content={"detail": str(exc)},
-    )
-
-# Or use HTTPException directly in service
-class UserService:
-    async def get_by_id(self, user_id: int) -> User:
-        user = await self.repository.get(user_id)
-        if not user:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"User {user_id} not found",
-            )
-        return user
-```
-
-### API Versioning
-
-```python
-from fastapi import APIRouter
-
-# Versioned routers
-v1_router = APIRouter(prefix="/api/v1")
-v1_router.include_router(users.router, prefix="/users", tags=["users"])
-v1_router.include_router(auth.router, prefix="/auth", tags=["auth"])
-
-v2_router = APIRouter(prefix="/api/v2")
-# ... v2 routes
-
-app.include_router(v1_router)
-app.include_router(v2_router)
-```