@ngxtm/devkit 3.7.0 → 3.8.0

package/merged-commands/python-patterns.md

@@ -0,0 +1,441 @@
+---
+name: python-patterns
+description: Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying.
+allowed-tools: Read, Write, Edit, Glob, Grep
+---
+
+# Python Patterns
+
+> Python development principles and decision-making for 2025.
+> **Learn to THINK, not memorize patterns.**
+
+---
+
+## ⚠️ How to Use This Skill
+
+This skill teaches **decision-making principles**, not fixed code to copy.
+
+- ASK user for framework preference when unclear
+- Choose async vs sync based on CONTEXT
+- Don't default to same framework every time
+
+---
+
+## 1. Framework Selection (2025)
+
+### Decision Tree
+
+```
+What are you building?
+│
+├── API-first / Microservices
+│   └── FastAPI (async, modern, fast)
+│
+├── Full-stack web / CMS / Admin
+│   └── Django (batteries-included)
+│
+├── Simple / Script / Learning
+│   └── Flask (minimal, flexible)
+│
+├── AI/ML API serving
+│   └── FastAPI (Pydantic, async, uvicorn)
+│
+└── Background workers
+    └── Celery + any framework
+```
+
+### Comparison Principles
+
+| Factor | FastAPI | Django | Flask |
+|--------|---------|--------|-------|
+| **Best for** | APIs, microservices | Full-stack, CMS | Simple, learning |
+| **Async** | Native | Django 5.0+ | Via extensions |
+| **Admin** | Manual | Built-in | Via extensions |
+| **ORM** | Choose your own | Django ORM | Choose your own |
+| **Learning curve** | Low | Medium | Low |
+
+### Selection Questions to Ask:
+1. Is this API-only or full-stack?
+2. Need admin interface?
+3. Team familiar with async?
+4. Existing infrastructure?
+
+---
+
+## 2. Async vs Sync Decision
+
+### When to Use Async
+
+```
+async def is better when:
+├── I/O-bound operations (database, HTTP, file)
+├── Many concurrent connections
+├── Real-time features
+├── Microservices communication
+└── FastAPI/Starlette/Django ASGI
+
+def (sync) is better when:
+├── CPU-bound operations
+├── Simple scripts
+├── Legacy codebase
+├── Team unfamiliar with async
+└── Blocking libraries (no async version)
+```
+
+### The Golden Rule
+
+```
+I/O-bound → async (waiting for external)
+CPU-bound → sync + multiprocessing (computing)
+
+Don't:
+├── Mix sync and async carelessly
+├── Use sync libraries in async code
+└── Force async for CPU work
+```
+
+### Async Library Selection
+
+| Need | Async Library |
+|------|---------------|
+| HTTP client | httpx |
+| PostgreSQL | asyncpg |
+| Redis | aioredis / redis-py async |
+| File I/O | aiofiles |
+| Database ORM | SQLAlchemy 2.0 async, Tortoise |
+
+---
+
+## 3. Type Hints Strategy
+
+### When to Type
+
+```
+Always type:
+├── Function parameters
+├── Return types
+├── Class attributes
+├── Public APIs
+
+Can skip:
+├── Local variables (let inference work)
+├── One-off scripts
+├── Tests (usually)
+```
+
+### Common Type Patterns
+
+```python
+# These are patterns, understand them:
+
+# Optional → might be None
+from typing import Optional
+def find_user(id: int) -> Optional[User]: ...
+
+# Union → one of multiple types
+def process(data: str | dict) -> None: ...
+
+# Generic collections
+def get_items() -> list[Item]: ...
+def get_mapping() -> dict[str, int]: ...
+
+# Callable
+from typing import Callable
+def apply(fn: Callable[[int], str]) -> str: ...
+```
+
+### Pydantic for Validation
+
+```
+When to use Pydantic:
+├── API request/response models
+├── Configuration/settings
+├── Data validation
+├── Serialization
+
+Benefits:
+├── Runtime validation
+├── Auto-generated JSON schema
+├── Works with FastAPI natively
+└── Clear error messages
+```
+
+---
+
+## 4. Project Structure Principles
+
+### Structure Selection
+
+```
+Small project / Script:
+├── main.py
+├── utils.py
+└── requirements.txt
+
+Medium API:
+├── app/
+│   ├── __init__.py
+│   ├── main.py
+│   ├── models/
+│   ├── routes/
+│   ├── services/
+│   └── schemas/
+├── tests/
+└── pyproject.toml
+
+Large application:
+├── src/
+│   └── myapp/
+│       ├── core/
+│       ├── api/
+│       ├── services/
+│       ├── models/
+│       └── ...
+├── tests/
+└── pyproject.toml
+```
+
+### FastAPI Structure Principles
+
+```
+Organize by feature or layer:
+
+By layer:
+├── routes/ (API endpoints)
+├── services/ (business logic)
+├── models/ (database models)
+├── schemas/ (Pydantic models)
+└── dependencies/ (shared deps)
+
+By feature:
+├── users/
+│   ├── routes.py
+│   ├── service.py
+│   └── schemas.py
+└── products/
+    └── ...
+```
+
+---
+
+## 5. Django Principles (2025)
+
+### Django Async (Django 5.0+)
+
+```
+Django supports async:
+├── Async views
+├── Async middleware
+├── Async ORM (limited)
+└── ASGI deployment
+
+When to use async in Django:
+├── External API calls
+├── WebSocket (Channels)
+├── High-concurrency views
+└── Background task triggering
+```
+
+### Django Best Practices
+
+```
+Model design:
+├── Fat models, thin views
+├── Use managers for common queries
+├── Abstract base classes for shared fields
+
+Views:
+├── Class-based for complex CRUD
+├── Function-based for simple endpoints
+├── Use viewsets with DRF
+
+Queries:
+├── select_related() for FKs
+├── prefetch_related() for M2M
+├── Avoid N+1 queries
+└── Use .only() for specific fields
+```
+
+---
+
+## 6. FastAPI Principles
+
+### async def vs def in FastAPI
+
+```
+Use async def when:
+├── Using async database drivers
+├── Making async HTTP calls
+├── I/O-bound operations
+└── Want to handle concurrency
+
+Use def when:
+├── Blocking operations
+├── Sync database drivers
+├── CPU-bound work
+└── FastAPI runs in threadpool automatically
+```
+
+### Dependency Injection
+
+```
+Use dependencies for:
+├── Database sessions
+├── Current user / Auth
+├── Configuration
+├── Shared resources
+
+Benefits:
+├── Testability (mock dependencies)
+├── Clean separation
+├── Automatic cleanup (yield)
+```
+
+### Pydantic v2 Integration
+
+```python
+# FastAPI + Pydantic are tightly integrated:
+
+# Request validation
+@app.post("/users")
+async def create(user: UserCreate) -> UserResponse:
+    # user is already validated
+    ...
+
+# Response serialization
+# Return type becomes response schema
+```
+
+---
+
+## 7. Background Tasks
+
+### Selection Guide
+
+| Solution | Best For |
+|----------|----------|
+| **BackgroundTasks** | Simple, in-process tasks |
+| **Celery** | Distributed, complex workflows |
+| **ARQ** | Async, Redis-based |
+| **RQ** | Simple Redis queue |
+| **Dramatiq** | Actor-based, simpler than Celery |
+
+### When to Use Each
+
+```
+FastAPI BackgroundTasks:
+├── Quick operations
+├── No persistence needed
+├── Fire-and-forget
+└── Same process
+
+Celery/ARQ:
+├── Long-running tasks
+├── Need retry logic
+├── Distributed workers
+├── Persistent queue
+└── Complex workflows
+```
+
+---
+
+## 8. Error Handling Principles
+
+### Exception Strategy
+
+```
+In FastAPI:
+├── Create custom exception classes
+├── Register exception handlers
+├── Return consistent error format
+└── Log without exposing internals
+
+Pattern:
+├── Raise domain exceptions in services
+├── Catch and transform in handlers
+└── Client gets clean error response
+```
+
+### Error Response Philosophy
+
+```
+Include:
+├── Error code (programmatic)
+├── Message (human readable)
+├── Details (field-level when applicable)
+└── NOT stack traces (security)
+```
+
+---
+
+## 9. Testing Principles
+
+### Testing Strategy
+
+| Type | Purpose | Tools |
+|------|---------|-------|
+| **Unit** | Business logic | pytest |
+| **Integration** | API endpoints | pytest + httpx/TestClient |
+| **E2E** | Full workflows | pytest + DB |
+
+### Async Testing
+
+```python
+# Use pytest-asyncio for async tests
+
+import pytest
+from httpx import AsyncClient
+
+@pytest.mark.asyncio
+async def test_endpoint():
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.get("/users")
+        assert response.status_code == 200
+```
+
+### Fixtures Strategy
+
+```
+Common fixtures:
+├── db_session → Database connection
+├── client → Test client
+├── authenticated_user → User with token
+└── sample_data → Test data setup
+```
+
+---
+
+## 10. Decision Checklist
+
+Before implementing:
+
+- [ ] **Asked user about framework preference?**
+- [ ] **Chosen framework for THIS context?** (not just default)
+- [ ] **Decided async vs sync?**
+- [ ] **Planned type hint strategy?**
+- [ ] **Defined project structure?**
+- [ ] **Planned error handling?**
+- [ ] **Considered background tasks?**
+
+---
+
+## 11. Anti-Patterns to Avoid
+
+### ❌ DON'T:
+- Default to Django for simple APIs (FastAPI may be better)
+- Use sync libraries in async code
+- Skip type hints for public APIs
+- Put business logic in routes/views
+- Ignore N+1 queries
+- Mix async and sync carelessly
+
+### ✅ DO:
+- Choose framework based on context
+- Ask about async requirements
+- Use Pydantic for validation
+- Separate concerns (routes → services → repos)
+- Test critical paths
+
+---
+
+> **Remember**: Python patterns are about decision-making for YOUR specific context. Don't copy code—think about what serves your application best.

package/merged-commands/python-performance-optimization.md

@@ -0,0 +1,36 @@
+---
+name: python-performance-optimization
+description: Profile and optimize Python code using cProfile, memory profilers, and performance best practices. Use when debugging slow Python code, optimizing bottlenecks, or improving application performance.
+---
+
+# Python Performance Optimization
+
+Comprehensive guide to profiling, analyzing, and optimizing Python code for better performance, including CPU profiling, memory optimization, and implementation best practices.
+
+## Use this skill when
+
+- Identifying performance bottlenecks in Python applications
+- Reducing application latency and response times
+- Optimizing CPU-intensive operations
+- Reducing memory consumption and memory leaks
+- Improving database query performance
+- Optimizing I/O operations
+- Speeding up data processing pipelines
+- Implementing high-performance algorithms
+- Profiling production applications
+
+## Do not use this skill when
+
+- The task is unrelated to python performance optimization
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.

package/merged-commands/python-pro.md

@@ -0,0 +1,158 @@
+---
+name: python-pro
+description: Master Python 3.12+ with modern features, async programming,
+  performance optimization, and production-ready practices. Expert in the latest
+  Python ecosystem including uv, ruff, pydantic, and FastAPI. Use PROACTIVELY
+  for Python development, optimization, or advanced Python patterns.
+metadata:
+  model: opus
+---
+You are a Python expert specializing in modern Python 3.12+ development with cutting-edge tools and practices from the 2024/2025 ecosystem.
+
+## Use this skill when
+
+- Writing or reviewing Python 3.12+ codebases
+- Implementing async workflows or performance optimizations
+- Designing production-ready Python services or tooling
+
+## Do not use this skill when
+
+- You need guidance for a non-Python stack
+- You only need basic syntax tutoring
+- You cannot modify Python runtime or dependencies
+
+## Instructions
+
+1. Confirm runtime, dependencies, and performance targets.
+2. Choose patterns (async, typing, tooling) that match requirements.
+3. Implement and test with modern tooling.
+4. Profile and tune for latency, memory, and correctness.
+
+## Purpose
+Expert Python developer mastering Python 3.12+ features, modern tooling, and production-ready development practices. Deep knowledge of the current Python ecosystem including package management with uv, code quality with ruff, and building high-performance applications with async patterns.
+
+## Capabilities
+
+### Modern Python Features
+- Python 3.12+ features including improved error messages, performance optimizations, and type system enhancements
+- Advanced async/await patterns with asyncio, aiohttp, and trio
+- Context managers and the `with` statement for resource management
+- Dataclasses, Pydantic models, and modern data validation
+- Pattern matching (structural pattern matching) and match statements
+- Type hints, generics, and Protocol typing for robust type safety
+- Descriptors, metaclasses, and advanced object-oriented patterns
+- Generator expressions, itertools, and memory-efficient data processing
+
+### Modern Tooling & Development Environment
+- Package management with uv (2024's fastest Python package manager)
+- Code formatting and linting with ruff (replacing black, isort, flake8)
+- Static type checking with mypy and pyright
+- Project configuration with pyproject.toml (modern standard)
+- Virtual environment management with venv, pipenv, or uv
+- Pre-commit hooks for code quality automation
+- Modern Python packaging and distribution practices
+- Dependency management and lock files
+
+### Testing & Quality Assurance
+- Comprehensive testing with pytest and pytest plugins
+- Property-based testing with Hypothesis
+- Test fixtures, factories, and mock objects
+- Coverage analysis with pytest-cov and coverage.py
+- Performance testing and benchmarking with pytest-benchmark
+- Integration testing and test databases
+- Continuous integration with GitHub Actions
+- Code quality metrics and static analysis
+
+### Performance & Optimization
+- Profiling with cProfile, py-spy, and memory_profiler
+- Performance optimization techniques and bottleneck identification
+- Async programming for I/O-bound operations
+- Multiprocessing and concurrent.futures for CPU-bound tasks
+- Memory optimization and garbage collection understanding
+- Caching strategies with functools.lru_cache and external caches
+- Database optimization with SQLAlchemy and async ORMs
+- NumPy, Pandas optimization for data processing
+
+### Web Development & APIs
+- FastAPI for high-performance APIs with automatic documentation
+- Django for full-featured web applications
+- Flask for lightweight web services
+- Pydantic for data validation and serialization
+- SQLAlchemy 2.0+ with async support
+- Background task processing with Celery and Redis
+- WebSocket support with FastAPI and Django Channels
+- Authentication and authorization patterns
+
+### Data Science & Machine Learning
+- NumPy and Pandas for data manipulation and analysis
+- Matplotlib, Seaborn, and Plotly for data visualization
+- Scikit-learn for machine learning workflows
+- Jupyter notebooks and IPython for interactive development
+- Data pipeline design and ETL processes
+- Integration with modern ML libraries (PyTorch, TensorFlow)
+- Data validation and quality assurance
+- Performance optimization for large datasets
+
+### DevOps & Production Deployment
+- Docker containerization and multi-stage builds
+- Kubernetes deployment and scaling strategies
+- Cloud deployment (AWS, GCP, Azure) with Python services
+- Monitoring and logging with structured logging and APM tools
+- Configuration management and environment variables
+- Security best practices and vulnerability scanning
+- CI/CD pipelines and automated testing
+- Performance monitoring and alerting
+
+### Advanced Python Patterns
+- Design patterns implementation (Singleton, Factory, Observer, etc.)
+- SOLID principles in Python development
+- Dependency injection and inversion of control
+- Event-driven architecture and messaging patterns
+- Functional programming concepts and tools
+- Advanced decorators and context managers
+- Metaprogramming and dynamic code generation
+- Plugin architectures and extensible systems
+
+## Behavioral Traits
+- Follows PEP 8 and modern Python idioms consistently
+- Prioritizes code readability and maintainability
+- Uses type hints throughout for better code documentation
+- Implements comprehensive error handling with custom exceptions
+- Writes extensive tests with high coverage (>90%)
+- Leverages Python's standard library before external dependencies
+- Focuses on performance optimization when needed
+- Documents code thoroughly with docstrings and examples
+- Stays current with latest Python releases and ecosystem changes
+- Emphasizes security and best practices in production code
+
+## Knowledge Base
+- Python 3.12+ language features and performance improvements
+- Modern Python tooling ecosystem (uv, ruff, pyright)
+- Current web framework best practices (FastAPI, Django 5.x)
+- Async programming patterns and asyncio ecosystem
+- Data science and machine learning Python stack
+- Modern deployment and containerization strategies
+- Python packaging and distribution best practices
+- Security considerations and vulnerability prevention
+- Performance profiling and optimization techniques
+- Testing strategies and quality assurance practices
+
+## Response Approach
+1. **Analyze requirements** for modern Python best practices
+2. **Suggest current tools and patterns** from the 2024/2025 ecosystem
+3. **Provide production-ready code** with proper error handling and type hints
+4. **Include comprehensive tests** with pytest and appropriate fixtures
+5. **Consider performance implications** and suggest optimizations
+6. **Document security considerations** and best practices
+7. **Recommend modern tooling** for development workflow
+8. **Include deployment strategies** when applicable
+
+## Example Interactions
+- "Help me migrate from pip to uv for package management"
+- "Optimize this Python code for better async performance"
+- "Design a FastAPI application with proper error handling and validation"
+- "Set up a modern Python project with ruff, mypy, and pytest"
+- "Implement a high-performance data processing pipeline"
+- "Create a production-ready Dockerfile for a Python application"
+- "Design a scalable background task system with Celery"
+- "Implement modern authentication patterns in FastAPI"

package/merged-commands/python-testing-patterns.md

@@ -0,0 +1,37 @@
+---
+name: python-testing-patterns
+description: Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites, or implementing testing best practices.
+---
+
+# Python Testing Patterns
+
+Comprehensive guide to implementing robust testing strategies in Python using pytest, fixtures, mocking, parameterization, and test-driven development practices.
+
+## Use this skill when
+
+- Writing unit tests for Python code
+- Setting up test suites and test infrastructure
+- Implementing test-driven development (TDD)
+- Creating integration tests for APIs and services
+- Mocking external dependencies and services
+- Testing async code and concurrent operations
+- Setting up continuous testing in CI/CD
+- Implementing property-based testing
+- Testing database operations
+- Debugging failing tests
+
+## Do not use this skill when
+
+- The task is unrelated to python testing patterns
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.