@ngxtm/devkit 3.14.0 → 3.16.0

package/skills/python-fastapi-development/SKILL.md

@@ -0,0 +1,216 @@
+---
+name: python-fastapi-development
+description: "Python FastAPI backend development with async patterns, SQLAlchemy, Pydantic, authentication, and production API patterns."
+source: personal
+risk: safe
+domain: backend-development
+category: granular-workflow-bundle
+version: 1.0.0
+---
+
+# Python/FastAPI Development Workflow
+
+## Overview
+
+Specialized workflow for building production-ready Python backends with FastAPI, featuring async patterns, SQLAlchemy ORM, Pydantic validation, and comprehensive API patterns.
+
+## When to Use This Workflow
+
+Use this workflow when:
+- Building new REST APIs with FastAPI
+- Creating async Python backends
+- Implementing database integration with SQLAlchemy
+- Setting up API authentication
+- Developing microservices
+
+## Workflow Phases
+
+### Phase 1: Project Setup
+
+#### Skills to Invoke
+- `app-builder` - Application scaffolding
+- `python-development-python-scaffold` - Python scaffolding
+- `fastapi-templates` - FastAPI templates
+- `uv-package-manager` - Package management
+
+#### Actions
+1. Set up Python environment (uv/poetry)
+2. Create project structure
+3. Configure FastAPI app
+4. Set up logging
+5. Configure environment variables
+
+#### Copy-Paste Prompts
+```
+Use @fastapi-templates to scaffold a new FastAPI project
+```
+
+```
+Use @python-development-python-scaffold to set up Python project structure
+```
+
+### Phase 2: Database Setup
+
+#### Skills to Invoke
+- `prisma-expert` - Prisma ORM (alternative)
+- `database-design` - Schema design
+- `postgresql` - PostgreSQL setup
+- `pydantic-models-py` - Pydantic models
+
+#### Actions
+1. Design database schema
+2. Set up SQLAlchemy models
+3. Create database connection
+4. Configure migrations (Alembic)
+5. Set up session management
+
+#### Copy-Paste Prompts
+```
+Use @database-design to design PostgreSQL schema
+```
+
+```
+Use @pydantic-models-py to create Pydantic models for API
+```
+
+### Phase 3: API Routes
+
+#### Skills to Invoke
+- `fastapi-router-py` - FastAPI routers
+- `api-design-principles` - API design
+- `api-patterns` - API patterns
+
+#### Actions
+1. Design API endpoints
+2. Create API routers
+3. Implement CRUD operations
+4. Add request validation
+5. Configure response models
+
+#### Copy-Paste Prompts
+```
+Use @fastapi-router-py to create API endpoints with CRUD operations
+```
+
+```
+Use @api-design-principles to design RESTful API
+```
+
+### Phase 4: Authentication
+
+#### Skills to Invoke
+- `auth-implementation-patterns` - Authentication
+- `api-security-best-practices` - API security
+
+#### Actions
+1. Choose auth strategy (JWT, OAuth2)
+2. Implement user registration
+3. Set up login endpoints
+4. Create auth middleware
+5. Add password hashing
+
+#### Copy-Paste Prompts
+```
+Use @auth-implementation-patterns to implement JWT authentication
+```
+
+### Phase 5: Error Handling
+
+#### Skills to Invoke
+- `fastapi-pro` - FastAPI patterns
+- `error-handling-patterns` - Error handling
+
+#### Actions
+1. Create custom exceptions
+2. Set up exception handlers
+3. Implement error responses
+4. Add request logging
+5. Configure error tracking
+
+#### Copy-Paste Prompts
+```
+Use @fastapi-pro to implement comprehensive error handling
+```
+
+### Phase 6: Testing
+
+#### Skills to Invoke
+- `python-testing-patterns` - pytest testing
+- `api-testing-observability-api-mock` - API testing
+
+#### Actions
+1. Set up pytest
+2. Create test fixtures
+3. Write unit tests
+4. Implement integration tests
+5. Configure test database
+
+#### Copy-Paste Prompts
+```
+Use @python-testing-patterns to write pytest tests for FastAPI
+```
+
+### Phase 7: Documentation
+
+#### Skills to Invoke
+- `api-documenter` - API documentation
+- `openapi-spec-generation` - OpenAPI specs
+
+#### Actions
+1. Configure OpenAPI schema
+2. Add endpoint documentation
+3. Create usage examples
+4. Set up API versioning
+5. Generate API docs
+
+#### Copy-Paste Prompts
+```
+Use @api-documenter to generate comprehensive API documentation
+```
+
+### Phase 8: Deployment
+
+#### Skills to Invoke
+- `deployment-engineer` - Deployment
+- `docker-expert` - Containerization
+
+#### Actions
+1. Create Dockerfile
+2. Set up docker-compose
+3. Configure production settings
+4. Set up reverse proxy
+5. Deploy to cloud
+
+#### Copy-Paste Prompts
+```
+Use @docker-expert to containerize FastAPI application
+```
+
+## Technology Stack
+
+| Category | Technology |
+|----------|------------|
+| Framework | FastAPI |
+| Language | Python 3.11+ |
+| ORM | SQLAlchemy 2.0 |
+| Validation | Pydantic v2 |
+| Database | PostgreSQL |
+| Migrations | Alembic |
+| Auth | JWT, OAuth2 |
+| Testing | pytest |
+
+## Quality Gates
+
+- [ ] All tests passing (>80% coverage)
+- [ ] Type checking passes (mypy)
+- [ ] Linting clean (ruff, black)
+- [ ] API documentation complete
+- [ ] Security scan passed
+- [ ] Performance benchmarks met
+
+## Related Workflow Bundles
+
+- `development` - General development
+- `database` - Database operations
+- `security-audit` - Security testing
+- `api-development` - API patterns

package/skills/python-packaging/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: python-packaging
-description: Create distributable Python packages with proper project structure, setup.py/pyproject.toml, and publishing to PyPI. Use when packaging Python libraries, creating CLI tools, or distributing Python code.
+description: "Create distributable Python packages with proper project structure, setup.py/pyproject.toml, and publishing to PyPI. Use when packaging Python libraries, creating CLI tools, or distributing Python ..."
+risk: unknown
+source: community
 ---
 
 # Python Packaging

package/skills/python-patterns/SKILL.md

@@ -1,7 +1,9 @@
 ---
 name: python-patterns
-description: Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying.
+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
+risk: unknown
+source: community
 ---
 
 # Python Patterns
@@ -9,6 +11,10 @@ allowed-tools: Read, Write, Edit, Glob, Grep
 > Python development principles and decision-making for 2025.
 > **Learn to THINK, not memorize patterns.**
 
+## When to Use
+
+Use this skill when making Python architecture decisions, choosing frameworks, designing async patterns, or structuring Python projects.
+
 ---
 
 ## ⚠️ How to Use This Skill

package/skills/python-performance-optimization/SKILL.md

@@ -1,6 +1,8 @@
 ---
 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.
+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."
+risk: unknown
+source: community
 ---
 
 # Python Performance Optimization

package/skills/python-pro/SKILL.md

@@ -1,158 +1,92 @@
 ---
 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
+description: Use when building Python 3.11+ applications requiring type safety, async programming, or production-grade patterns. Invoke for type hints, pytest, async/await, dataclasses, mypy configuration.
+triggers:
+  - Python development
+  - type hints
+  - async Python
+  - pytest
+  - mypy
+  - dataclasses
+  - Python best practices
+  - Pythonic code
+role: specialist
+scope: implementation
+output-format: code
 ---
-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"
+
+# Python Pro
+
+Senior Python developer with 10+ years experience specializing in type-safe, async-first, production-ready Python 3.11+ code.
+
+## Role Definition
+
+You are a senior Python engineer mastering modern Python 3.11+ and its ecosystem. You write idiomatic, type-safe, performant code across web development, data science, automation, and system programming with focus on production best practices.
+
+## When to Use This Skill
+
+- Writing type-safe Python with complete type coverage
+- Implementing async/await patterns for I/O operations
+- Setting up pytest test suites with fixtures and mocking
+- Creating Pythonic code with comprehensions, generators, context managers
+- Building packages with Poetry and proper project structure
+- Performance optimization and profiling
+
+## Core Workflow
+
+1. **Analyze codebase** - Review structure, dependencies, type coverage, test suite
+2. **Design interfaces** - Define protocols, dataclasses, type aliases
+3. **Implement** - Write Pythonic code with full type hints and error handling
+4. **Test** - Create comprehensive pytest suite with >90% coverage
+5. **Validate** - Run mypy, black, ruff; ensure quality standards met
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Type System | `references/type-system.md` | Type hints, mypy, generics, Protocol |
+| Async Patterns | `references/async-patterns.md` | async/await, asyncio, task groups |
+| Standard Library | `references/standard-library.md` | pathlib, dataclasses, functools, itertools |
+| Testing | `references/testing.md` | pytest, fixtures, mocking, parametrize |
+| Packaging | `references/packaging.md` | poetry, pip, pyproject.toml, distribution |
+
+## Constraints
+
+### MUST DO
+- Type hints for all function signatures and class attributes
+- PEP 8 compliance with black formatting
+- Comprehensive docstrings (Google style)
+- Test coverage exceeding 90% with pytest
+- Use `X | None` instead of `Optional[X]` (Python 3.10+)
+- Async/await for I/O-bound operations
+- Dataclasses over manual __init__ methods
+- Context managers for resource handling
+
+### MUST NOT DO
+- Skip type annotations on public APIs
+- Use mutable default arguments
+- Mix sync and async code improperly
+- Ignore mypy errors in strict mode
+- Use bare except clauses
+- Hardcode secrets or configuration
+- Use deprecated stdlib modules (use pathlib not os.path)
+
+## Output Templates
+
+When implementing Python features, provide:
+1. Module file with complete type hints
+2. Test file with pytest fixtures
+3. Type checking confirmation (mypy --strict passes)
+4. Brief explanation of Pythonic patterns used
+
+## Knowledge Reference
+
+Python 3.11+, typing module, mypy, pytest, black, ruff, dataclasses, async/await, asyncio, pathlib, functools, itertools, Poetry, Pydantic, contextlib, collections.abc, Protocol
+
+## Related Skills
+
+- **FastAPI Expert** - Async Python APIs
+- **Data Science Pro** - NumPy, Pandas, ML
+- **DevOps Engineer** - Python automation and tooling

package/skills/python-testing-patterns/SKILL.md

@@ -1,6 +1,8 @@
 ---
 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.
+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."
+risk: unknown
+source: community
 ---
 
 # Python Testing Patterns

package/skills/quant-analyst/SKILL.md

@@ -1,11 +1,13 @@
 ---
 name: quant-analyst
-description: Build financial models, backtest trading strategies, and analyze
+description: "Build financial models, backtest trading strategies, and analyze"
   market data. Implements risk metrics, portfolio optimization, and statistical
   arbitrage. Use PROACTIVELY for quantitative finance, trading algorithms, or
   risk analysis.
 metadata:
   model: inherit
+risk: unknown
+source: community
 ---
 
 ## Use this skill when

package/skills/radix-ui-design-system/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: radix-ui-design-system
-description: Build accessible design systems with Radix UI primitives. Headless component customization, theming strategies, and compound component patterns for production-grade UI libraries.
+description: "Build accessible design systems with Radix UI primitives. Headless component customization, theming strategies, and compound component patterns for production-grade UI libraries."
 risk: safe
 source: self
 ---

package/skills/rag-engineer/SKILL.md

@@ -1,7 +1,8 @@
 ---
 name: rag-engineer
-description: "Expert in building Retrieval-Augmented Generation systems. Masters embedding models, vector databases, chunking strategies, and retrieval optimization for LLM applications. Use when: building RAG, vector search, embeddings, semantic search, document retrieval."
+description: "Expert in building Retrieval-Augmented Generation systems. Masters embedding models, vector databases, chunking strategies, and retrieval optimization for LLM applications. Use when: building RAG, ..."
 source: vibeship-spawner-skills (Apache 2.0)
+risk: unknown
 ---
 
 # RAG Engineer
@@ -88,3 +89,6 @@ Combine semantic and keyword search
 ## Related Skills
 
 Works well with: `ai-agents-architect`, `prompt-engineer`, `database-architect`, `backend`
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.