@hivehub/rulebook 2.1.0 → 3.1.0

package/templates/skills/languages/python/SKILL.md

@@ -0,0 +1,692 @@
+---
+name: "Python"
+description: "Execute these commands after EVERY implementation (see AGENT_AUTOMATION module for full workflow)."
+version: "1.0.0"
+category: "languages"
+author: "Rulebook"
+tags: ["languages", "language"]
+dependencies: []
+conflicts: []
+---
+<!-- PYTHON:START -->
+# Python Project Rules
+
+## Agent Automation Commands
+
+**CRITICAL**: Execute these commands after EVERY implementation (see AGENT_AUTOMATION module for full workflow).
+
+```bash
+# Complete quality check sequence:
+ruff format --check .      # Format check
+ruff check .               # Linting
+mypy .                     # Type checking
+pytest                     # All tests (100% pass required)
+pytest --cov               # Coverage check (95%+ required)
+
+# Security audit:
+pip-audit                  # Vulnerability scan
+pip list --outdated        # Check outdated deps
+```
+
+## Python Version
+
+**CRITICAL**: Use Python 3.11+ for modern features and performance.
+
+- **Minimum Version**: Python 3.11+
+- **Recommended**: Python 3.12+
+- **Type Hints**: Required for all public APIs
+
+### Formatting
+
+- Use `ruff format` (fast, modern) or `black` (traditional)
+- Line length: 100 characters (configurable)
+- Consistent formatting across entire project
+- Format before committing
+
+Configuration in `pyproject.toml`:
+```toml
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+```
+
+### Linting
+
+- Use `ruff check` (fast, comprehensive) or `ruff` + `flake8`
+- Fix all linting errors before committing
+- Document any disabled rules with justification
+
+Configuration in `pyproject.toml`:
+```toml
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "W", "UP", "B", "A", "C4", "SIM"]
+ignore = ["E501"]  # Line too long (handled by formatter)
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]  # Allow assert in tests
+```
+
+### Type Checking
+
+- Use `mypy` for static type checking
+- All public APIs must have type hints
+- Use `typing` module for complex types
+- Gradual typing allowed for legacy code
+
+Configuration in `pyproject.toml`:
+```toml
+[tool.mypy]
+python_version = "3.11"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+```
+
+Example:
+```python
+from typing import Optional, List, Dict, Any
+
+def process_data(
+    input_data: str,
+    options: Optional[Dict[str, Any]] = None
+) -> List[str]:
+    """Process input data and return results."""
+    # Implementation
+    return []
+```
+
+### Testing
+
+- **Framework**: pytest
+- **Location**: `/tests` directory
+- **Coverage**: Must meet project threshold (default 95%)
+- **Fixtures**: Use pytest fixtures for setup/teardown
+- **Parametrize**: Use `@pytest.mark.parametrize` for multiple test cases
+
+Example test structure:
+```python
+import pytest
+from mymodule import process_data
+
+@pytest.fixture
+def sample_data():
+    """Provide sample data for tests."""
+    return "test input"
+
+def test_process_data_valid_input(sample_data):
+    """Test process_data with valid input."""
+    result = process_data(sample_data)
+    assert result == ["expected"]
+
+@pytest.mark.parametrize("input_val,expected", [
+    ("hello", ["HELLO"]),
+    ("world", ["WORLD"]),
+])
+def test_process_data_parametrized(input_val, expected):
+    """Test multiple input cases."""
+    result = process_data(input_val)
+    assert result == expected
+```
+
+### Test Categories: S2S and Slow Tests
+
+**CRITICAL**: Tests must be categorized based on execution time and dependencies.
+
+#### Test Time Limits
+
+- **Fast Tests**: Must complete in ≤ 10-20 seconds
+- **Slow Tests**: Any test taking > 10-20 seconds must be marked as slow
+- **S2S Tests**: Tests requiring active server/database must be isolated and run on-demand
+
+#### S2S (Server-to-Server) Tests
+
+**Tests that require active servers, databases, or external services must be isolated using pytest markers.**
+
+**Implementation**:
+
+1. **Mark S2S tests with pytest markers**:
+```python
+import pytest
+import os
+
+# Regular fast test (always runs)
+def test_local_computation():
+    """Fast test, no external dependencies."""
+    result = compute_locally("input")
+    assert result == "expected"
+
+# S2S test (only runs with -m s2s)
+@pytest.mark.s2s
+def test_database_connection():
+    """Requires active database server."""
+    db = connect_to_database()
+    # ... test implementation
+
+@pytest.mark.s2s
+def test_api_integration():
+    """Requires active API server."""
+    client = create_api_client()
+    # ... test implementation
+```
+
+2. **Configure `pytest.ini` or `pyproject.toml`**:
+```ini
+# pytest.ini
+[pytest]
+markers =
+    s2s: Server-to-server tests requiring active services
+    slow: Slow tests taking > 20 seconds
+```
+
+Or in `pyproject.toml`:
+```toml
+[tool.pytest.ini_options]
+markers = [
+    "s2s: Server-to-server tests requiring active services",
+    "slow: Slow tests taking > 20 seconds",
+]
+```
+
+3. **Run tests**:
+```bash
+# Regular tests (excludes S2S)
+pytest
+
+# Include S2S tests (requires active servers)
+pytest -m s2s
+
+# Run all tests including S2S
+pytest -m "not slow"  # Fast + S2S, excludes slow
+```
+
+#### Slow Tests
+
+**Tests that take > 10-20 seconds must be marked and run separately.**
+
+**Implementation**:
+
+1. **Mark slow tests with pytest markers**:
+```python
+import pytest
+
+# Fast test (always runs)
+def test_quick_operation():
+    """Completes in < 1 second."""
+    result = quick_compute("input")
+    assert result == "expected"
+
+# Slow test (only runs with -m slow)
+@pytest.mark.slow
+def test_heavy_computation():
+    """Takes 30+ seconds."""
+    # Heavy processing, large dataset, etc.
+    result = process_large_dataset()
+    assert result is not None
+
+@pytest.mark.slow
+def test_large_file_processing():
+    """Processes large files, takes > 20 seconds."""
+    result = process_file("large_file.dat")
+    assert result.success
+```
+
+2. **Run tests**:
+```bash
+# Regular tests (excludes slow and S2S)
+pytest -m "not slow and not s2s"
+
+# Include slow tests
+pytest -m slow
+
+# Run all tests
+pytest -m ""  # Empty marker means all tests
+```
+
+3. **Add pytest configuration for timeouts**:
+```python
+# conftest.py
+import pytest
+
+@pytest.fixture(autouse=True)
+def configure_timeouts(request):
+    """Configure timeouts based on test markers."""
+    if 'slow' in request.keywords:
+        request.node.add_marker(pytest.mark.timeout(300))  # 5 minutes
+    elif 's2s' in request.keywords:
+        request.node.add_marker(pytest.mark.timeout(60))  # 1 minute
+    else:
+        request.node.add_marker(pytest.mark.timeout(20))  # 20 seconds
+```
+
+4. **Add scripts in `pyproject.toml` or `setup.py`**:
+```toml
+[tool.poetry.scripts]
+test = "pytest -m 'not slow and not s2s'"
+test-s2s = "pytest -m s2s"
+test-slow = "pytest -m slow"
+test-all = "pytest"
+```
+
+#### Best Practices
+
+- ✅ **Always run fast tests** in CI/CD by default
+- ✅ **Isolate S2S tests** - never run them in standard test suite
+- ✅ **Mark slow tests** - prevent CI/CD timeouts
+- ✅ **Document requirements** - specify which servers/services are needed for S2S tests
+- ✅ **Use timeouts** - Set appropriate timeouts: `@pytest.mark.timeout(60)`
+- ✅ **Use pytest markers** - `@pytest.mark.s2s` and `@pytest.mark.slow`
+- ✅ **Skip conditionally** - `@pytest.mark.skipif(not os.getenv('RUN_S2S_TESTS'), reason='S2S tests disabled')`
+- ❌ **Never mix** fast and slow/S2S tests in same test run
+- ❌ **Never require** external services for standard test suite
+- ❌ **Never exceed** 10-20 seconds for regular tests
+
+## Dependency Management
+
+**CRITICAL**: Use modern dependency management tools.
+
+### Recommended: Poetry
+
+```toml
+[tool.poetry]
+name = "myproject"
+version = "0.1.0"
+description = ""
+authors = ["Your Name <you@example.com>"]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+requests = "^2.31.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+mypy = "^1.5.0"
+ruff = "^0.1.0"
+```
+
+Commands:
+```bash
+poetry install              # Install dependencies
+poetry add requests         # Add dependency
+poetry add --group dev pytest  # Add dev dependency
+poetry update               # Update dependencies
+```
+
+### Alternative: pip-tools
+
+```
+# requirements.in
+requests>=2.31.0
+pydantic>=2.0.0
+
+# requirements-dev.in
+-r requirements.in
+pytest>=7.4.0
+mypy>=1.5.0
+```
+
+Commands:
+```bash
+pip-compile requirements.in
+pip-compile requirements-dev.in
+pip-sync requirements-dev.txt
+```
+
+### Dependency Guidelines
+
+1. **Check for latest versions**:
+   - Use Context7 MCP tool if available
+   - Check PyPI: `pip index versions <package>`
+   - Review changelog for breaking changes
+
+2. **Version pinning**:
+   - ✅ Pin exact versions in applications
+   - ✅ Use ranges in libraries (`>=1.0,<2.0`)
+   - ✅ Keep dependencies updated regularly
+   - ❌ Don't use outdated packages with security issues
+
+## Error Handling
+
+- Use specific exception types
+- Create custom exceptions when needed
+- Document exceptions in docstrings
+- Never use bare `except:`
+
+Example:
+```python
+class ValidationError(Exception):
+    """Raised when data validation fails."""
+    
+    def __init__(self, message: str, field: str):
+        super().__init__(message)
+        self.field = field
+
+def validate_data(data: dict[str, Any]) -> None:
+    """
+    Validate input data.
+    
+    Args:
+        data: The data to validate
+        
+    Raises:
+        ValidationError: If validation fails
+    """
+    if not isinstance(data, dict):
+        raise ValidationError("Data must be a dictionary", "data")
+```
+
+## Documentation
+
+- **Docstrings**: Google or NumPy style
+- **Type hints**: Required for public APIs
+- **README**: Include installation and usage
+- **API docs**: Consider Sphinx for large projects
+
+Example (Google style):
+```python
+def process_data(input_data: str, options: dict[str, Any] | None = None) -> list[str]:
+    """
+    Process input data and return results.
+    
+    Args:
+        input_data: The input string to process
+        options: Optional processing options
+        
+    Returns:
+        A list of processed strings
+        
+    Raises:
+        ValidationError: If input_data is empty
+        
+    Examples:
+        >>> process_data("hello")
+        ['HELLO']
+        >>> process_data("world", {"lowercase": True})
+        ['world']
+    """
+    # Implementation
+    return []
+```
+
+## Project Structure
+
+```
+project/
+├── pyproject.toml      # Project metadata and dependencies
+├── README.md           # Project overview (allowed in root)
+├── CHANGELOG.md        # Version history (allowed in root)
+├── AGENTS.md          # AI assistant rules (allowed in root)
+├── LICENSE            # Project license (allowed in root)
+├── CONTRIBUTING.md    # Contribution guidelines (allowed in root)
+├── CODE_OF_CONDUCT.md # Code of conduct (allowed in root)
+├── SECURITY.md        # Security policy (allowed in root)
+├── src/
+│   └── mypackage/
+│       ├── __init__.py
+│       ├── module.py
+│       └── py.typed    # PEP 561 marker for type hints
+├── tests/              # Test files
+│   ├── __init__.py
+│   └── test_module.py
+└── docs/               # Documentation
+```
+
+## Async Programming
+
+- Use `asyncio` for async code
+- Type hints: `async def func() -> Coroutine`
+- Testing: Use `pytest-asyncio`
+
+Example:
+```python
+import asyncio
+from typing import List
+
+async def fetch_data(url: str) -> dict[str, Any]:
+    """Fetch data asynchronously."""
+    # Implementation
+    return {}
+
+async def main() -> None:
+    """Main async function."""
+    results = await asyncio.gather(
+        fetch_data("url1"),
+        fetch_data("url2"),
+    )
+    print(results)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## CI/CD Requirements
+
+Must include GitHub Actions workflows for:
+
+1. **Testing** (`python-test.yml`):
+   - Test on ubuntu-latest, windows-latest, macos-latest
+   - Test on Python 3.11, 3.12
+   - Upload coverage reports
+
+2. **Linting** (`python-lint.yml`):
+   - Format check: `ruff format --check .`
+   - Lint: `ruff check .`
+   - Type check: `mypy .`
+
+3. **Security** (`python-security.yml`):
+   - Check for vulnerabilities: `pip-audit`
+   - Scan dependencies: `safety check`
+
+## Package Publication
+
+### Publishing to PyPI
+
+**Prerequisites:**
+1. Create account at https://pypi.org
+2. Enable 2FA for security
+3. Configure trusted publishing (recommended) or create API token
+4. For trusted publishing: Add GitHub as publisher in PyPI settings
+
+**pyproject.toml Configuration:**
+
+```toml
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "your-package-name"
+version = "1.0.0"
+description = "A short description of your package"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "your.email@example.com"}
+]
+keywords = ["your", "keywords"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "requests>=2.31.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4.0",
+    "pytest-cov>=4.1.0",
+    "ruff>=0.1.0",
+    "mypy>=1.7.0",
+    "black>=23.12.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/your-org/your-package"
+Documentation = "https://your-package.readthedocs.io"
+Repository = "https://github.com/your-org/your-package"
+"Bug Tracker" = "https://github.com/your-org/your-package/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+your_package = ["py.typed"]
+```
+
+### PEP 625 Package Naming Convention
+
+**CRITICAL**: Package names must be normalized according to PEP 625.
+
+PyPI requires source distribution filenames to use normalized package names (underscores instead of hyphens).
+
+**Naming Rules:**
+
+1. **Package name in `pyproject.toml`**: Use underscores (`_`)
+   ```toml
+   [project]
+   name = "my_package_name"  # Correct
+   # NOT: name = "my-package-name"  # Will cause deprecation warning
+   ```
+
+2. **Package directory**: Must match with underscores
+   ```
+   src/
+   └── my_package_name/     # Correct
+       ├── __init__.py
+       └── ...
+   ```
+
+3. **Import statement**: Uses underscores
+   ```python
+   import my_package_name
+   from my_package_name import something
+   ```
+
+4. **Distribution filename**: Will be `my_package_name-1.0.0.tar.gz` ✅
+
+**Common Issue:**
+
+If you use hyphens in the package name, PyPI will reject new uploads:
+```toml
+# ❌ WRONG - Will fail PEP 625 compliance
+[project]
+name = "my-package-name"
+
+# Result: my-package-name-1.0.0.tar.gz (non-compliant)
+# PyPI Error: "Filename does not contain normalized project name"
+```
+
+**Correct Approach:**
+```toml
+# ✅ CORRECT - PEP 625 compliant
+[project]
+name = "my_package_name"
+
+# Result: my_package_name-1.0.0.tar.gz (compliant)
+# PyPI: Accepts upload without warnings
+```
+
+**Migration from Hyphenated Names:**
+
+If you previously published with hyphens:
+
+1. Update `pyproject.toml` and `setup.py` to use underscores
+2. Existing uploads remain on PyPI (no action needed)
+3. Future uploads will use normalized name
+4. PyPI will automatically redirect:
+   - `pip install my-package-name` → works (auto-normalized)
+   - `pip install my_package_name` → works (canonical form)
+5. Import statement unchanged: `import my_package_name`
+
+**Reference**: [PEP 625 - File name of a Source Distribution](https://peps.python.org/pep-0625/)
+
+**Publishing Workflow:**
+
+1. Update version in pyproject.toml
+2. Update CHANGELOG.md
+3. Run quality checks:
+   ```bash
+   ruff check .
+   ruff format --check .
+   mypy .
+   pytest
+   ```
+4. Build package:
+   ```bash
+   python -m build
+   twine check dist/*
+   ```
+5. Test on Test PyPI (optional):
+   ```bash
+   twine upload --repository testpypi dist/*
+   ```
+6. Create git tag: `git tag v1.0.0 && git push --tags`
+7. GitHub Actions automatically publishes to PyPI
+8. Or manual publish: `twine upload dist/*`
+
+**Publishing Checklist:**
+
+- ✅ All tests passing (`pytest`)
+- ✅ Type checking passes (`mypy .`)
+- ✅ Linting passes (`ruff check .`)
+- ✅ Code formatted (`ruff format .`)
+- ✅ Version updated in pyproject.toml
+- ✅ CHANGELOG.md updated
+- ✅ README.md up to date
+- ✅ LICENSE file present
+- ✅ **Package name uses underscores (PEP 625 compliant)**
+- ✅ `py.typed` marker for type hints
+- ✅ Package builds successfully (`python -m build`)
+- ✅ Package checks pass (`twine check dist/*`)
+- ✅ Manifest complete (`check-manifest`)
+- ✅ **Verify dist filename**: `my_package-1.0.0.tar.gz` (underscores) ✅
+
+**Trusted Publishing (Recommended):**
+
+PyPI trusted publishing eliminates the need for API tokens:
+
+1. Go to PyPI → Your Account → Publishing
+2. Add a new pending publisher:
+   - PyPI Project Name: `your-package-name`
+   - Owner: `your-github-org`
+   - Repository: `your-repo-name`
+   - Workflow: `python-publish.yml`
+   - Environment: `release` (optional)
+
+3. GitHub Actions will authenticate automatically using OIDC
+
+**Versioning:**
+
+Use semantic versioning and consider:
+- **Automated versioning**: Use tools like `bump2version` or `setuptools_scm`
+- **Version from git tags**: Configure `setuptools_scm` in pyproject.toml:
+
+```toml
+[build-system]
+requires = ["setuptools>=68.0", "setuptools_scm>=8.0"]
+
+[tool.setuptools_scm]
+version_file = "src/your_package/_version.py"
+```
+
+**Type Hints:**
+
+Include `py.typed` marker for PEP 561 compliance:
+```bash
+touch src/your_package/py.typed
+```
+
+This tells type checkers your package includes type information.
+
+<!-- PYTHON:END -->
+