@martinffx/atelier 2.0.0 → 3.0.1

package/skills/python-temporal/SKILL.md

@@ -1,128 +0,0 @@
----
-name: python-temporal
-description: Temporal workflow orchestration in Python. Use when designing workflows, implementing activities, handling retries, managing workflow state, or building durable distributed systems.
-user-invocable: false
----
-
-# Temporal Workflow Orchestration
-
-Temporal SDK patterns for building durable, distributed workflows in Python.
-
-## Worker Setup
-
-```python
-from temporalio.client import Client
-from temporalio.worker import Worker
-
-async def main():
-    client = await Client.connect("localhost:7233")
-
-    worker = Worker(
-        client,
-        task_queue="my-task-queue",
-        workflows=[MyWorkflow],
-        activities=[my_activity],
-    )
-
-    await worker.run()
-```
-
-## Workflow Definition
-
-```python
-from temporalio import workflow
-from datetime import timedelta
-
-@workflow.defn
-class MyWorkflow:
-    @workflow.run
-    async def run(self, name: str) -> str:
-        """Workflow run method"""
-        # Execute activity
-        result = await workflow.execute_activity(
-            my_activity,
-            name,
-            start_to_close_timeout=timedelta(seconds=30),
-        )
-
-        return f"Hello {result}"
-```
-
-## Activity Implementation
-
-```python
-from temporalio import activity
-
-@activity.defn
-async def my_activity(name: str) -> str:
-    """Activity - can fail and retry"""
-    # Do work (database, API, etc.)
-    return name.upper()
-```
-
-## Starting Workflows
-
-```python
-from temporalio.client import Client
-
-async def start_workflow():
-    client = await Client.connect("localhost:7233")
-
-    handle = await client.start_workflow(
-        MyWorkflow.run,
-        "World",
-        id="my-workflow-id",
-        task_queue="my-task-queue",
-    )
-
-    result = await handle.result()
-    print(result)  # "Hello WORLD"
-```
-
-## Error Handling
-
-```python
-from temporalio.exceptions import ActivityError
-
-@workflow.defn
-class MyWorkflow:
-    @workflow.run
-    async def run(self) -> str:
-        try:
-            result = await workflow.execute_activity(
-                risky_activity,
-                start_to_close_timeout=timedelta(seconds=30),
-                retry_policy=RetryPolicy(maximum_attempts=3),
-            )
-        except ActivityError as e:
-            # Handle failure after retries exhausted
-            return "Failed"
-
-        return result
-```
-
-## Signals and Queries
-
-```python
-@workflow.defn
-class OrderWorkflow:
-    def __init__(self):
-        self.status = "pending"
-
-    @workflow.run
-    async def run(self, order_id: str) -> str:
-        await workflow.wait_condition(lambda: self.status == "approved")
-        return "Order processed"
-
-    @workflow.signal
-    def approve(self):
-        """Signal to approve order"""
-        self.status = "approved"
-
-    @workflow.query
-    def get_status(self) -> str:
-        """Query current status"""
-        return self.status
-```
-
-See references/ for testing patterns and common workflow patterns.

package/skills/python-temporal/references/patterns.md

@@ -1,87 +0,0 @@
-# Common Temporal Workflow Patterns
-
-## Saga Pattern
-
-```python
-@workflow.defn
-class SagaWorkflow:
-    @workflow.run
-    async def run(self, order_id: str):
-        """Saga with compensations"""
-        try:
-            # Step 1: Reserve inventory
-            await workflow.execute_activity(
-                reserve_inventory,
-                order_id,
-                start_to_close_timeout=timedelta(seconds=30),
-            )
-
-            # Step 2: Charge payment
-            await workflow.execute_activity(
-                charge_payment,
-                order_id,
-                start_to_close_timeout=timedelta(seconds=30),
-            )
-
-            # Step 3: Ship order
-            await workflow.execute_activity(
-                ship_order,
-                order_id,
-                start_to_close_timeout=timedelta(seconds=30),
-            )
-
-        except Exception:
-            # Compensate in reverse order
-            await workflow.execute_activity(release_inventory, order_id)
-            await workflow.execute_activity(refund_payment, order_id)
-            raise
-```
-
-## Fan-Out/Fan-In
-
-```python
-@workflow.defn
-class FanOutWorkflow:
-    @workflow.run
-    async def run(self, items: list[str]):
-        """Process items in parallel"""
-        # Fan-out: start all activities
-        tasks = [
-            workflow.execute_activity(
-                process_item,
-                item,
-                start_to_close_timeout=timedelta(seconds=30),
-            )
-            for item in items
-        ]
-
-        # Fan-in: wait for all
-        results = await asyncio.gather(*tasks)
-        return results
-```
-
-## Long-Running Approval
-
-```python
-@workflow.defn
-class ApprovalWorkflow:
-    def __init__(self):
-        self.approved = False
-
-    @workflow.run
-    async def run(self, request_id: str):
-        """Wait for approval (can wait days/weeks)"""
-        await workflow.wait_condition(
-            lambda: self.approved,
-            timeout=timedelta(days=7),
-        )
-
-        if self.approved:
-            await workflow.execute_activity(process_request, request_id)
-        else:
-            await workflow.execute_activity(reject_request, request_id)
-
-    @workflow.signal
-    def approve(self):
-        self.approved = True
-```

package/skills/python-temporal/references/testing.md

@@ -1,54 +0,0 @@
-# Testing Temporal Workflows
-
-## Test Environment
-
-```python
-from temporalio.testing import WorkflowEnvironment
-from temporalio.worker import Worker
-
-async def test_workflow():
-    """Test workflow in test environment"""
-    async with await WorkflowEnvironment.start_time_skipping() as env:
-        # Create worker
-        async with Worker(
-            env.client,
-            task_queue="test-queue",
-            workflows=[MyWorkflow],
-            activities=[my_activity],
-        ):
-            # Execute workflow
-            result = await env.client.execute_workflow(
-                MyWorkflow.run,
-                "World",
-                id="test-workflow",
-                task_queue="test-queue",
-            )
-
-            assert result == "Hello WORLD"
-```
-
-## Activity Mocking
-
-```python
-from unittest.mock import Mock
-
-async def test_workflow_with_mock_activity():
-    """Mock activity in test"""
-    mock_activity = Mock(return_value="MOCKED")
-
-    async with await WorkflowEnvironment.start_time_skipping() as env:
-        async with Worker(
-            env.client,
-            task_queue="test-queue",
-            workflows=[MyWorkflow],
-            activities=[mock_activity],
-        ):
-            result = await env.client.execute_workflow(
-                MyWorkflow.run,
-                "World",
-                id="test-workflow",
-                task_queue="test-queue",
-            )
-
-            assert result == "Hello MOCKED"
-```

package/skills/python-testing/SKILL.md

@@ -1,161 +0,0 @@
----
-name: python-testing
-description: Stub-Driven TDD and layer boundary testing with pytest. Use when writing tests, deciding what to test, testing at component boundaries, or implementing test-driven development.
-user-invocable: false
----
-
-# Testing with pytest
-
-Stub-Driven TDD and layer boundary testing patterns for Python applications.
-
-## Core Principle: Stub-Driven TDD
-
-Test at component boundaries, not internal implementation:
-
-```
-Router → Service → Repository → Entity → Database
-   ↓        ↓           ↓          ↓
- Test    Test        Test       Test
-```
-
-Follow the **Stub → Test → Implement → Refactor** workflow:
-
-1. **Stub** - Create function signature with `pass`
-2. **Test** - Write test for expected behavior
-3. **Implement** - Make test pass
-4. **Refactor** - Clean up code
-
-```python
-# 1. Stub
-def calculate_discount(total: Decimal) -> Decimal:
-    pass
-
-# 2. Test
-def test_discount_for_large_order():
-    result = calculate_discount(Decimal("150"))
-    assert result == Decimal("15")
-
-# 3. Implement
-def calculate_discount(total: Decimal) -> Decimal:
-    if total > 100:
-        return total * Decimal("0.1")
-    return Decimal("0")
-```
-
-## Layer Boundary Testing Overview
-
-Test **what crosses layer boundaries**, not internal implementation:
-
-- **Entity Layer**: Domain logic, validation, transformations (from_request, to_response, to_record)
-- **Service Layer**: Business workflows, error handling, dependency orchestration
-- **Repository Layer**: CRUD operations, query logic, entity ↔ record transformations
-- **Router Layer**: Request validation, response serialization, status codes
-
-See references/boundaries.md for comprehensive layer-specific examples.
-
-## Entity Testing Example
-
-Test transformations and business logic:
-
-```python
-def test_product_from_request():
-    """Test creation from request"""
-    request = CreateProductRequest(name="Widget", price=Decimal("9.99"))
-    product = Product.from_request(request)
-
-    assert product.name == "Widget"
-    assert product.price == Decimal("9.99")
-    assert isinstance(product.id, UUID)
-
-def test_product_apply_discount():
-    """Test business logic"""
-    product = Product(id=uuid4(), name="Widget", price=Decimal("100"))
-    discounted = product.apply_discount(Decimal("0.1"))
-
-    assert discounted.price == Decimal("90")
-```
-
-## Service Testing Example
-
-Test orchestration with stubbed dependencies:
-
-```python
-from unittest.mock import Mock
-
-def test_create_product_service():
-    """Test with mocked repository"""
-    mock_repo = Mock()
-    mock_repo.save.return_value = Product(id=uuid4(), name="Widget")
-
-    service = ProductService(repo=mock_repo)
-    result = service.create(CreateProductRequest(name="Widget", price=Decimal("9.99")))
-
-    mock_repo.save.assert_called_once()
-    assert result.name == "Widget"
-```
-
-## Repository Testing Example
-
-Test data access with real test database:
-
-```python
-@pytest.fixture
-def test_db():
-    """In-memory test database"""
-    engine = create_engine("sqlite:///:memory:")
-    Base.metadata.create_all(engine)
-    return sessionmaker(bind=engine)()
-
-def test_repository_save(test_db):
-    """Test database operations"""
-    repo = ProductRepository(test_db)
-    product = Product(id=uuid4(), name="Widget", price=Decimal("9.99"))
-
-    saved = repo.save(product)
-
-    assert saved.id == product.id
-    assert test_db.query(ProductRecord).count() == 1
-```
-
-## Router Testing Example
-
-Test HTTP layer with TestClient:
-
-```python
-from fastapi.testclient import TestClient
-
-def test_create_product_endpoint():
-    """Test POST endpoint"""
-    client = TestClient(app)
-
-    response = client.post(
-        "/products",
-        json={"name": "Widget", "price": 9.99},
-    )
-
-    assert response.status_code == 201
-    assert response.json()["name"] == "Widget"
-```
-
-## Test Organization Basics
-
-```
-tests/
-├── unit/
-│   ├── test_entities.py      # Entity + Value object tests
-│   └── test_services.py      # Service tests (with mocks)
-├── integration/
-│   ├── test_repositories.py  # Repository tests (with DB)
-│   └── test_endpoints.py     # Router tests (with client)
-└── conftest.py               # Shared fixtures
-```
-
-## Reference Documentation
-
-For comprehensive patterns and examples, see:
-
-- **references/boundaries.md** - Layer boundary testing patterns with complete examples for each layer
-- **references/mocking.md** - Mock strategies, verification methods, and anti-patterns
-- **references/pytest.md** - Configuration, fixtures, markers, parametrization, and debugging
-
-Progressive disclosure: SKILL.md provides quick reference, references/ contain full details.