@damiangilgonzalez/harness 1.3.7

package/skills/muscle-memory/assets/library-seed/adapter/card.md

@@ -0,0 +1,29 @@
+# Adapter
+
+## What it is
+The Adapter pattern wraps an object with an incompatible interface so it can be used wherever the expected interface is required, without modifying the wrapped object. The adapter translates calls: it receives a call in the new shape and turns it into the call(s) the wrapped (often legacy or third-party) object actually understands.
+
+## Idiomatic example
+```python
+class LegacyLogger:
+    def write_log(self, text):
+        print(f'[legacy] {text}')
+
+
+class LoggerAdapter:
+    def __init__(self, legacy_logger):
+        self.legacy_logger = legacy_logger
+
+    def log(self, message):
+        self.legacy_logger.write_log(message)
+```
+
+## Common mistakes
+- Modifying the legacy/third-party class directly instead of wrapping it, coupling your code to something you don't control or can't safely change.
+- Building an adapter that only renames a method (`log` calls `write_log`) when the real incompatibility is in the *data shape* — the adapter also needs to transform arguments, not just forward them.
+- Forgetting that an adapter can hold state (e.g. "has this been initialized yet") when the legacy interface needs multiple calls to do what the new interface does in one.
+
+## Where you see it in real code
+- ORM/driver adapters that expose a common `execute(query)` interface over different underlying database client libraries.
+- Third-party SDK wrappers in a codebase, isolating a vendor's clunky API behind the app's own clean interface.
+- Adapting between sync and async interfaces, or between an old versioned API response shape and the shape the rest of the app expects.

package/skills/muscle-memory/assets/library-seed/adapter/katas/l2-printer-adapter.json

@@ -0,0 +1,9 @@
+{
+  "concept": "adapter",
+  "level": 2,
+  "title_en": "Wrap a legacy printer behind a new interface",
+  "spec_html_en": "<p>There is a legacy <code>OldPrinter</code> class with method <code>send(text)</code> returning <code>f\"printed: {text}\"</code>. Write class <code>PrinterAdapter</code>: <code>__init__(self, old_printer)</code> stores it, and <code>render(self, document)</code> delegates to the wrapped printer's <code>send</code> method and returns its result unchanged.</p>",
+  "stub": "class OldPrinter:\n    def send(self, text):\n        return f'printed: {text}'\n\n\nclass PrinterAdapter:\n    # TODO: implement __init__ and render, delegating to the wrapped OldPrinter.send\n    pass\n",
+  "test": "def test_adapter_delegates_to_legacy_send():\n    adapter = PrinterAdapter(OldPrinter())\n    assert adapter.render('invoice #1') == 'printed: invoice #1', 'render must delegate to the legacy send() method'\n\ndef test_adapter_works_with_different_printers():\n    class MockPrinter:\n        def send(self, text):\n            return f'MOCK[{text}]'\n    adapter = PrinterAdapter(MockPrinter())\n    assert adapter.render('test') == 'MOCK[test]', 'the adapter must work with any object exposing a compatible send() method'\n\ndef test_render_returns_a_string():\n    adapter = PrinterAdapter(OldPrinter())\n    result = adapter.render('')\n    assert isinstance(result, str), 'render must return a string'\n",
+  "canonical": "class OldPrinter:\n    def send(self, text):\n        return f'printed: {text}'\n\n\nclass PrinterAdapter:\n    def __init__(self, old_printer):\n        self.old_printer = old_printer\n\n    def render(self, document):\n        return self.old_printer.send(document)\n"
+}

package/skills/muscle-memory/assets/library-seed/adapter/katas/l3-analytics-adapter.json

@@ -0,0 +1,9 @@
+{
+  "concept": "adapter",
+  "level": 3,
+  "title_en": "Build AnalyticsAdapter composing a legacy two-call API",
+  "spec_html_en": "<p>Legacy <code>LegacyAnalytics</code> requires two separate calls: <code>start_session(session_id)</code> then <code>log_event(session_id, event)</code>. Write class <code>AnalyticsAdapter</code> composing a <code>LegacyAnalytics</code> instance and a <code>session_id</code>. Its single method <code>track(self, event)</code> must adapt the new one-call interface to the legacy one: on the very first call it must call <code>start_session</code> before logging, and on every call it must call <code>log_event</code>. The session must be started at most once, even across multiple <code>track</code> calls.</p>",
+  "stub": "class LegacyAnalytics:\n    def __init__(self):\n        self.calls = []\n\n    def start_session(self, session_id):\n        self.calls.append(('start', session_id))\n\n    def log_event(self, session_id, event):\n        self.calls.append(('event', session_id, event))\n\n\nclass AnalyticsAdapter:\n    def __init__(self, legacy, session_id):\n        self.legacy = legacy\n        self.session_id = session_id\n        self.started = False\n\n    def track(self, event):\n        # TODO: implement per spec: start the session on the first call only,\n        # then always log the event\n        ...\n",
+  "test": "def test_first_track_starts_session_then_logs():\n    legacy = LegacyAnalytics()\n    adapter = AnalyticsAdapter(legacy, 'sess-1')\n    adapter.track('click')\n    assert legacy.calls == [('start', 'sess-1'), ('event', 'sess-1', 'click')], 'the first track() must start the session before logging the event'\n\ndef test_second_track_does_not_start_again():\n    legacy = LegacyAnalytics()\n    adapter = AnalyticsAdapter(legacy, 'sess-1')\n    adapter.track('click')\n    adapter.track('scroll')\n    assert legacy.calls == [\n        ('start', 'sess-1'),\n        ('event', 'sess-1', 'click'),\n        ('event', 'sess-1', 'scroll'),\n    ], 'a second track() must only log the event, not start the session again'\n\ndef test_multiple_adapters_track_independent_sessions():\n    legacy = LegacyAnalytics()\n    a = AnalyticsAdapter(legacy, 'sess-a')\n    b = AnalyticsAdapter(legacy, 'sess-b')\n    a.track('open')\n    b.track('open')\n    assert legacy.calls == [\n        ('start', 'sess-a'),\n        ('event', 'sess-a', 'open'),\n        ('start', 'sess-b'),\n        ('event', 'sess-b', 'open'),\n    ], 'each adapter must manage its own started flag independently'\n",
+  "canonical": "class LegacyAnalytics:\n    def __init__(self):\n        self.calls = []\n\n    def start_session(self, session_id):\n        self.calls.append(('start', session_id))\n\n    def log_event(self, session_id, event):\n        self.calls.append(('event', session_id, event))\n\n\nclass AnalyticsAdapter:\n    def __init__(self, legacy, session_id):\n        self.legacy = legacy\n        self.session_id = session_id\n        self.started = False\n\n    def track(self, event):\n        if not self.started:\n            self.legacy.start_session(self.session_id)\n            self.started = True\n        self.legacy.log_event(self.session_id, event)\n"
+}

package/skills/muscle-memory/assets/library-seed/async/card.md

@@ -0,0 +1,25 @@
+# `async`/`await`
+
+## What it is
+`async def` defines a coroutine: calling it doesn't run the body immediately, it returns a coroutine object that must be awaited or scheduled to actually run. `await` pauses the current coroutine until another awaitable finishes, letting the event loop run other work meanwhile. `asyncio.run(...)` starts the event loop and runs one coroutine to completion; `asyncio.gather(...)` runs several coroutines concurrently and waits for all of them.
+
+## Idiomatic example
+```python
+import asyncio
+
+async def fetch(name: str) -> str:
+    await asyncio.sleep(0.01)
+    return f"{name}: ok"
+
+asyncio.run(fetch("service"))
+```
+
+## Common mistakes
+- Calling an `async def` function without `await`/`asyncio.run` — you get a coroutine object back, not the result, and Python warns it was "never awaited".
+- Using `time.sleep()` inside a coroutine instead of `await asyncio.sleep()` — it blocks the whole event loop instead of yielding control.
+- Awaiting independent coroutines one by one in a loop instead of running them concurrently with `asyncio.gather(...)`.
+
+## Where you see it in real code
+- Concurrent HTTP calls to multiple services, gathered together instead of awaited sequentially.
+- Async web frameworks (FastAPI route handlers) that `await` database or network calls without blocking other requests.
+- Background tasks that poll or wait for an event without freezing the rest of the program.

package/skills/muscle-memory/assets/library-seed/async/katas/l2-service-health.json

@@ -0,0 +1,9 @@
+{
+  "concept": "async",
+  "level": 2,
+  "title_en": "Build an async check_service_health coroutine",
+  "spec_html_en": "<p>Write async function <code>check_service_health(service_name)</code> that awaits <code>asyncio.sleep(0)</code> (simulating a network check) and returns <code>f\"{service_name}: healthy\"</code>.</p>",
+  "stub": "import asyncio\n\n\nasync def check_service_health(service_name):\n    # TODO: implement per spec, awaiting asyncio.sleep(0)\n    ...\n",
+  "test": "async def test_returns_formatted_status():\n    result = await check_service_health('billing')\n    assert result == 'billing: healthy', 'must return \"<service_name>: healthy\" after awaiting'\n\ndef test_is_a_coroutine_function():\n    import inspect\n    assert inspect.iscoroutinefunction(check_service_health), 'check_service_health must be defined with async def'\n\nasync def test_runs_for_different_services():\n    result = await check_service_health('auth')\n    assert result == 'auth: healthy', 'the formatted status must reflect the given service_name'",
+  "canonical": "import asyncio\n\n\nasync def check_service_health(service_name):\n    await asyncio.sleep(0)\n    return f'{service_name}: healthy'\n"
+}

package/skills/muscle-memory/assets/library-seed/async/katas/l3-fetch-all-statuses.json

@@ -0,0 +1,9 @@
+{
+  "concept": "async",
+  "level": 3,
+  "title_en": "Fetch device statuses concurrently with asyncio.gather",
+  "spec_html_en": "<p>Write async function <code>fetch_status(device_id)</code> that awaits <code>asyncio.sleep(0)</code> and returns <code>f\"{device_id}: online\"</code>. Write async function <code>fetch_all_statuses(device_ids)</code> that uses <code>asyncio.gather</code> to run <code>fetch_status</code> for every id in <code>device_ids</code> concurrently, returning the results as a list in the same order.</p>",
+  "stub": "import asyncio\n\n\nasync def fetch_status(device_id):\n    # TODO: implement per spec, awaiting asyncio.sleep(0)\n    ...\n\n\nasync def fetch_all_statuses(device_ids):\n    # TODO: implement per spec, using asyncio.gather\n    ...\n",
+  "test": "async def test_fetch_status_single_device():\n    result = await fetch_status('sensor-1')\n    assert result == 'sensor-1: online', 'fetch_status must return \"<device_id>: online\"'\n\nasync def test_fetch_all_statuses_preserves_order():\n    result = await fetch_all_statuses(['a', 'b', 'c'])\n    assert result == ['a: online', 'b: online', 'c: online'], 'results must be in the same order as the input device_ids'\n\nasync def test_fetch_all_statuses_empty_list():\n    result = await fetch_all_statuses([])\n    assert result == [], 'gathering zero coroutines must return an empty list'",
+  "canonical": "import asyncio\n\n\nasync def fetch_status(device_id):\n    await asyncio.sleep(0)\n    return f'{device_id}: online'\n\n\nasync def fetch_all_statuses(device_ids):\n    return await asyncio.gather(*(fetch_status(d) for d in device_ids))\n"
+}

package/skills/muscle-memory/assets/library-seed/classes/card.md

@@ -0,0 +1,23 @@
+# Classes and `__init__`
+
+## What it is
+A class bundles related data and behavior together. `__init__` is the constructor: it runs once when you create an instance, and its job is to set up the object's initial state on `self`. Reach for a class when you have data that always travels together with the operations that act on it.
+
+## Idiomatic example
+```python
+class Ticket:
+    def __init__(self, title: str, priority: int = 0):
+        self.title = title
+        self.priority = priority
+```
+
+## Common mistakes
+- Forgetting `self` as the first parameter of `__init__` (and every instance method).
+- Using a mutable default argument (`def __init__(self, tags=[])`) — it is shared across all instances.
+- Assigning to a bare local variable instead of `self.attr`, so the value never sticks to the instance.
+- Doing real work (I/O, network calls) inside `__init__` instead of just setting up state.
+
+## Where you see it in real code
+- ORM models (SQLAlchemy, Django) are classes whose `__init__`/fields describe a database row.
+- Service/handler classes that group a resource (e.g. `PaymentProcessor`) with the config it needs.
+- DTOs and request/response objects in API clients.

package/skills/muscle-memory/assets/library-seed/classes/katas/l1-init.json

@@ -0,0 +1,9 @@
+{
+  "concept": "classes",
+  "level": 1,
+  "title_en": "Fill in the constructor",
+  "spec_html_en": "<p>The class <code>Account</code> needs its constructor: store <code>owner</code> and start <code>balance</code> at 0.</p>",
+  "stub": "class Account:\n    # TODO: __init__ storing owner, balance starts at 0\n    ...\n\n    def deposit(self, amount):\n        self.balance += amount\n",
+  "test": "def test_stores_owner():\n    a = Account('Ana')\n    assert a.owner == 'Ana', 'constructor must store owner'\n\ndef test_balance_starts_at_zero():\n    a = Account('Ana')\n    assert a.balance == 0, 'a new account must start with balance 0'\n\ndef test_deposit_works_on_top():\n    a = Account('Ana')\n    a.deposit(50)\n    assert a.balance == 50, 'deposit(50) on a fresh account must leave balance 50'",
+  "canonical": "class Account:\n    def __init__(self, owner):\n        self.owner = owner\n        self.balance = 0\n\n    def deposit(self, amount):\n        self.balance += amount\n"
+}

package/skills/muscle-memory/assets/library-seed/classes/katas/l2-invoice.json

@@ -0,0 +1,9 @@
+{
+  "concept": "classes",
+  "level": 2,
+  "title_en": "Build an Invoice class from the spec",
+  "spec_html_en": "<p>Write a class <code>Invoice</code> with <code>__init__(self, customer, amount, tax_rate=0.0)</code>. Add a method <code>total()</code> returning <code>amount + amount * tax_rate</code>.</p>",
+  "stub": "class Invoice:\n    # TODO: implement __init__ and total() per spec\n    pass\n",
+  "test": "def test_total_no_tax():\n    inv = Invoice('Ana', 100)\n    assert inv.total() == 100, 'total() must equal amount when tax_rate is 0'\n\ndef test_total_with_tax():\n    inv = Invoice('Bo', 200, 0.1)\n    assert abs(inv.total() - 220) < 1e-9, 'total() must add tax_rate * amount'\n\ndef test_stores_customer():\n    inv = Invoice('Cy', 50)\n    assert inv.customer == 'Cy', 'constructor must store customer'",
+  "canonical": "class Invoice:\n    def __init__(self, customer, amount, tax_rate=0.0):\n        self.customer = customer\n        self.amount = amount\n        self.tax_rate = tax_rate\n\n    def total(self):\n        return self.amount + self.amount * self.tax_rate\n"
+}

package/skills/muscle-memory/assets/library-seed/comprehensions/card.md

@@ -0,0 +1,20 @@
+# List and dict comprehensions
+
+## What it is
+A comprehension builds a new list/dict/set from an iterable in a single expression: `[expr for item in iterable if condition]`. It replaces the common pattern of creating an empty container, looping, and appending — same result, less code.
+
+## Idiomatic example
+```python
+prices = {"pen": 1.5, "mug": 8.0, "bag": 25.0}
+cheap_names = [name for name, price in prices.items() if price < 10]
+```
+
+## Common mistakes
+- Nesting so many loops/conditions into one comprehension that it becomes harder to read than the original `for` loop — past 2 clauses, prefer a plain loop or a helper function.
+- Using a comprehension purely for side effects (e.g. `[print(x) for x in items]`) instead of a normal `for` loop — comprehensions should build a value.
+- Forgetting a dict comprehension needs `key: value`, not just an expression — `{x for x in items}` builds a set, not a dict.
+
+## Where you see it in real code
+- Transforming API response rows into a lookup dict (`{row["id"]: row for row in rows}`).
+- Filtering and mapping collections in one line (`[u.email for u in users if u.active]`).
+- Building sets of unique values out of a larger list (`{item.category for item in items}`).

package/skills/muscle-memory/assets/library-seed/comprehensions/katas/l2-ticket-queue.json

@@ -0,0 +1,9 @@
+{
+  "concept": "comprehensions",
+  "level": 2,
+  "title_en": "Filter and map a support ticket queue",
+  "spec_html_en": "<p>Given a list of ticket dicts with keys <code>id</code>, <code>title</code>, <code>urgent</code>, write <code>urgent_titles(tickets)</code> returning a list of <code>title</code> for tickets where <code>urgent</code> is <code>True</code>, using a list comprehension. Write <code>titles_by_id(tickets)</code> returning a dict mapping <code>id</code> to <code>title</code> for every ticket, using a dict comprehension.</p>",
+  "stub": "def urgent_titles(tickets):\n    # TODO: implement with a list comprehension per spec\n    ...\n\n\ndef titles_by_id(tickets):\n    # TODO: implement with a dict comprehension per spec\n    ...\n",
+  "test": "def test_urgent_titles_filters():\n    tickets = [\n        {'id': 1, 'title': 'Server down', 'urgent': True},\n        {'id': 2, 'title': 'Typo in docs', 'urgent': False},\n        {'id': 3, 'title': 'Data loss', 'urgent': True},\n    ]\n    assert urgent_titles(tickets) == ['Server down', 'Data loss'], 'must return titles of urgent tickets only, in order'\n\ndef test_titles_by_id_maps_all_tickets():\n    tickets = [{'id': 1, 'title': 'Server down', 'urgent': True}, {'id': 2, 'title': 'Typo', 'urgent': False}]\n    assert titles_by_id(tickets) == {1: 'Server down', 2: 'Typo'}, 'must map every ticket id to its title, urgent or not'\n\ndef test_empty_ticket_list():\n    assert urgent_titles([]) == [], 'no tickets means no urgent titles'\n    assert titles_by_id([]) == {}, 'no tickets means an empty mapping'",
+  "canonical": "def urgent_titles(tickets):\n    return [t['title'] for t in tickets if t['urgent']]\n\n\ndef titles_by_id(tickets):\n    return {t['id']: t['title'] for t in tickets}\n"
+}

package/skills/muscle-memory/assets/library-seed/comprehensions/katas/l4-heavy-pallets.json

@@ -0,0 +1,9 @@
+{
+  "concept": "comprehensions",
+  "level": 4,
+  "title_en": "Refactor a loop into a list comprehension",
+  "spec_html_en": "<p><code>heavy_pallet_ids(pallets, limit)</code> returns the <code>id</code> of every pallet dict in <code>pallets</code> whose <code>weight</code> is strictly greater than <code>limit</code>. It already works with a manual loop; rewrite its body as a single list comprehension.</p>",
+  "stub": "def heavy_pallet_ids(pallets, limit):\n    # TODO: rewrite this loop as a single list comprehension\n    result = []\n    for pallet in pallets:\n        if pallet['weight'] > limit:\n            result.append(pallet['id'])\n    return result\n",
+  "test": "def test_filters_heavier_than_limit():\n    pallets = [{'id': 'A', 'weight': 500}, {'id': 'B', 'weight': 1200}, {'id': 'C', 'weight': 900}]\n    assert heavy_pallet_ids(pallets, 800) == ['B', 'C'], 'must return ids of pallets heavier than the limit, in order'\n\ndef test_weight_equal_to_limit_is_excluded():\n    pallets = [{'id': 'A', 'weight': 800}]\n    assert heavy_pallet_ids(pallets, 800) == [], 'a pallet exactly at the limit is not \"over\" it, so it must be excluded'\n\ndef test_empty_pallet_list():\n    assert heavy_pallet_ids([], 100) == [], 'no pallets means an empty result'",
+  "canonical": "def heavy_pallet_ids(pallets, limit):\n    return [pallet['id'] for pallet in pallets if pallet['weight'] > limit]\n"
+}

package/skills/muscle-memory/assets/library-seed/context-managers/card.md

@@ -0,0 +1,26 @@
+# Context managers (`with`, `__enter__`/`__exit__`)
+
+## What it is
+A context manager guarantees setup and teardown around a block of code, even if it raises: `__enter__` runs on entering the `with` block, `__exit__` always runs on leaving it. `contextlib.contextmanager` turns a generator function into a context manager without writing a class: everything before `yield` is `__enter__`, everything after is `__exit__`.
+
+## Idiomatic example
+```python
+from contextlib import contextmanager
+
+@contextmanager
+def timer(log: list):
+    log.append("start")
+    yield
+    log.append("end")
+```
+
+## Common mistakes
+- Forgetting `__exit__` must return a truthy value to suppress an exception — returning `None` (the default) lets the exception propagate, which is usually what you want.
+- Writing a `@contextmanager` generator with no `yield` (or more than one), instead of exactly one.
+- Doing cleanup in `__enter__` instead of `__exit__`, so it never runs if the `with` block fails partway through.
+- Not wrapping the `yield` in `try`/`finally` inside a `@contextmanager` function, so a failing block skips the cleanup.
+
+## Where you see it in real code
+- Database transactions and connection pools (`with connection.cursor() as cur:`).
+- File handles (`with open(path) as f:`) that always close, even on error.
+- Temporarily patching config or state in tests (`with mock.patch(...):`).

package/skills/muscle-memory/assets/library-seed/context-managers/katas/l2-managed-connection.json

@@ -0,0 +1,9 @@
+{
+  "concept": "context-managers",
+  "level": 2,
+  "title_en": "Build ManagedConnection with __enter__/__exit__",
+  "spec_html_en": "<p>Write class <code>ManagedConnection</code> implementing the context manager protocol. <code>__init__(self, name, log)</code> stores both. <code>__enter__</code> appends <code>f\"{name}:open\"</code> to <code>log</code> and returns <code>self</code>. <code>__exit__</code> appends <code>f\"{name}:closed\"</code> to <code>log</code> regardless of exception, and returns <code>False</code> (never suppress exceptions).</p>",
+  "stub": "class ManagedConnection:\n    # TODO: implement __init__, __enter__ and __exit__ per spec\n    pass\n",
+  "test": "def test_enter_appends_open():\n    log = []\n    with ManagedConnection('db', log):\n        pass\n    assert 'db:open' in log, '__enter__ must append \"<name>:open\" to log'\n\ndef test_exit_appends_closed_in_order():\n    log = []\n    with ManagedConnection('db', log):\n        pass\n    assert log == ['db:open', 'db:closed'], '__exit__ must append \"<name>:closed\" right after the block runs'\n\ndef test_exit_runs_even_on_error():\n    log = []\n    try:\n        with ManagedConnection('db', log):\n            raise ValueError('boom')\n    except ValueError:\n        pass\n    assert 'db:closed' in log, '__exit__ must run even if the with-block raises'",
+  "canonical": "class ManagedConnection:\n    def __init__(self, name, log):\n        self.name = name\n        self.log = log\n\n    def __enter__(self):\n        self.log.append(f'{self.name}:open')\n        return self\n\n    def __exit__(self, exc_type, exc_value, traceback):\n        self.log.append(f'{self.name}:closed')\n        return False\n"
+}

package/skills/muscle-memory/assets/library-seed/context-managers/katas/l3-maintenance-mode.json

@@ -0,0 +1,9 @@
+{
+  "concept": "context-managers",
+  "level": 3,
+  "title_en": "Build maintenance_mode with @contextmanager",
+  "spec_html_en": "<p>Write <code>maintenance_mode(system, log)</code> as a <code>@contextmanager</code> generator function. On enter, append <code>'entering maintenance'</code> to <code>log</code> and set <code>system.status = 'maintenance'</code>. On exit, always restore <code>system.status = 'normal'</code> and append <code>'exiting maintenance'</code> to <code>log</code>, even if the block raised.</p>",
+  "stub": "from contextlib import contextmanager\n\n\nclass System:\n    def __init__(self):\n        self.status = 'normal'\n\n\n@contextmanager\ndef maintenance_mode(system, log):\n    # TODO: implement per spec, using try/finally so the exit step always runs\n    ...\n",
+  "test": "def test_sets_and_restores_status():\n    system = System()\n    log = []\n    with maintenance_mode(system, log):\n        assert system.status == 'maintenance', 'status must be \"maintenance\" inside the block'\n    assert system.status == 'normal', 'status must be restored to \"normal\" after the block'\n\ndef test_logs_enter_and_exit_in_order():\n    system = System()\n    log = []\n    with maintenance_mode(system, log):\n        pass\n    assert log == ['entering maintenance', 'exiting maintenance'], 'log must record enter then exit, in order'\n\ndef test_restores_status_even_on_error():\n    system = System()\n    log = []\n    try:\n        with maintenance_mode(system, log):\n            raise RuntimeError('boom')\n    except RuntimeError:\n        pass\n    assert system.status == 'normal', 'status must be restored even if the block raises'\n    assert 'exiting maintenance' in log, 'exit must be logged even if the block raises'",
+  "canonical": "from contextlib import contextmanager\n\n\nclass System:\n    def __init__(self):\n        self.status = 'normal'\n\n\n@contextmanager\ndef maintenance_mode(system, log):\n    log.append('entering maintenance')\n    system.status = 'maintenance'\n    try:\n        yield\n    finally:\n        system.status = 'normal'\n        log.append('exiting maintenance')\n"
+}

package/skills/muscle-memory/assets/library-seed/dataclasses/card.md

@@ -0,0 +1,25 @@
+# `@dataclass`
+
+## What it is
+`@dataclass` generates `__init__`, `__repr__` and `__eq__` for you from type-annotated class fields, so you stop hand-writing boilerplate for classes that are mostly a bag of data. Use `field(default_factory=...)` when a default needs to be a fresh mutable object per instance.
+
+## Idiomatic example
+```python
+from dataclasses import dataclass, field
+
+@dataclass
+class Order:
+    order_id: str
+    items: list = field(default_factory=list)
+    discount: float = 0.0
+```
+
+## Common mistakes
+- Using a mutable literal as a default (`items: list = []`) instead of `field(default_factory=list)` — raises `ValueError` in a dataclass, and is a shared-state bug elsewhere.
+- Putting a field without a default before one with a default, which is a `TypeError` at class definition time.
+- Forgetting that `@dataclass` equality compares field values, not identity — don't add a custom `__eq__` unless you mean to override that.
+
+## Where you see it in real code
+- API request/response schemas and config objects.
+- Value objects passed between layers (e.g. `SensorReading`, `CartItem`).
+- Lightweight domain entities before reaching for a full ORM model.

package/skills/muscle-memory/assets/library-seed/dataclasses/katas/l1-product.json

@@ -0,0 +1,9 @@
+{
+  "concept": "dataclasses",
+  "level": 1,
+  "title_en": "Add fields to a dataclass",
+  "spec_html_en": "<p>Turn <code>Product</code> into a dataclass with fields <code>name: str</code>, <code>price: float</code> and <code>in_stock: bool = True</code>.</p>",
+  "stub": "from dataclasses import dataclass\n\n\n@dataclass\nclass Product:\n    # TODO: add fields name: str, price: float, in_stock: bool = True\n    pass\n",
+  "test": "def test_fields_stored():\n    p = Product('Widget', 9.99)\n    assert p.name == 'Widget', 'name must be stored'\n    assert p.price == 9.99, 'price must be stored'\n\ndef test_default_in_stock():\n    p = Product('Widget', 9.99)\n    assert p.in_stock is True, 'in_stock must default to True'\n\ndef test_repr_contains_name():\n    p = Product('Gadget', 5)\n    assert 'Gadget' in repr(p), 'dataclass repr must include field values'",
+  "canonical": "from dataclasses import dataclass\n\n\n@dataclass\nclass Product:\n    name: str\n    price: float\n    in_stock: bool = True\n"
+}

package/skills/muscle-memory/assets/library-seed/dataclasses/katas/l2-shopping-cart.json

@@ -0,0 +1,9 @@
+{
+  "concept": "dataclasses",
+  "level": 2,
+  "title_en": "Build ShoppingCart with a safe mutable default",
+  "spec_html_en": "<p>Write a dataclass <code>ShoppingCart</code> with field <code>owner: str</code> and field <code>items</code> that defaults to an independent empty list per instance (use <code>field(default_factory=list)</code>).</p>",
+  "stub": "from dataclasses import dataclass, field\n\n\nclass ShoppingCart:\n    # TODO: turn into a dataclass per spec: owner: str, items defaulting to an\n    # independent empty list via field(default_factory=list)\n    pass\n",
+  "test": "def test_owner_stored():\n    cart = ShoppingCart('Ana')\n    assert cart.owner == 'Ana', 'owner must be stored'\n\ndef test_items_default_empty():\n    cart = ShoppingCart('Ana')\n    assert cart.items == [], 'items must default to an empty list'\n\ndef test_items_are_independent_per_instance():\n    cart1 = ShoppingCart('Ana')\n    cart2 = ShoppingCart('Bo')\n    cart1.items.append('apple')\n    assert cart2.items == [], 'each ShoppingCart must get its own items list, not a shared one'",
+  "canonical": "from dataclasses import dataclass, field\n\n\n@dataclass\nclass ShoppingCart:\n    owner: str\n    items: list = field(default_factory=list)\n"
+}

package/skills/muscle-memory/assets/library-seed/decorators/card.md

@@ -0,0 +1,26 @@
+# Decorators
+
+## What it is
+A decorator wraps a function to add behavior (logging, timing, retrying) without changing its body. `@my_decorator` above a function is sugar for `func = my_decorator(func)`. Always use `functools.wraps` inside the wrapper so the decorated function keeps its original `__name__` and docstring.
+
+## Idiomatic example
+```python
+from functools import wraps
+
+def log_calls(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        print(f"calling {func.__name__}")
+        return func(*args, **kwargs)
+    return wrapper
+```
+
+## Common mistakes
+- Forgetting `@wraps(func)` on the inner wrapper, so introspection tools see the wrapper's name/docstring instead of the original function's.
+- Forgetting to `return` the wrapper from the decorator, or forgetting the wrapper returns the wrapped call's result.
+- Building a decorator *with arguments* but missing one level of nesting — it needs three: `decorator_factory(args) -> decorator(func) -> wrapper(*a, **kw)`.
+
+## Where you see it in real code
+- Web framework routes (`@app.get("/users")`), which register a function without changing how it's called.
+- Caching (`@functools.lru_cache`) and retry/backoff decorators around flaky I/O calls.
+- Access control (`@login_required`) wrapping view functions with a check before the real body runs.

package/skills/muscle-memory/assets/library-seed/decorators/katas/l2-count-calls.json

@@ -0,0 +1,9 @@
+{
+  "concept": "decorators",
+  "level": 2,
+  "title_en": "Build a count_calls decorator",
+  "spec_html_en": "<p>Write decorator <code>count_calls(func)</code> that counts how many times the wrapped function has been called, storing the count on <code>wrapper.calls</code>. Use <code>functools.wraps</code> so the wrapped function keeps its original name, and return the wrapped function's result unchanged.</p>",
+  "stub": "from functools import wraps\n\n\ndef count_calls(func):\n    # TODO: implement per spec: wraps func, tracks the number of calls on\n    # wrapper.calls, and returns func's result unchanged\n    ...\n",
+  "test": "def test_wrapped_function_still_works():\n    @count_calls\n    def add(a, b):\n        return a + b\n    assert add(2, 3) == 5, 'the decorated function must still return the original result'\n\ndef test_counts_every_call():\n    @count_calls\n    def ping():\n        return 'pong'\n    ping()\n    ping()\n    ping()\n    assert ping.calls == 3, 'calls must be counted across every invocation'\n\ndef test_preserves_function_name():\n    @count_calls\n    def greet():\n        return 'hi'\n    assert greet.__name__ == 'greet', 'functools.wraps must preserve the original __name__'",
+  "canonical": "from functools import wraps\n\n\ndef count_calls(func):\n    @wraps(func)\n    def wrapper(*args, **kwargs):\n        wrapper.calls += 1\n        return func(*args, **kwargs)\n    wrapper.calls = 0\n    return wrapper\n"
+}

package/skills/muscle-memory/assets/library-seed/decorators/katas/l3-retry.json

@@ -0,0 +1,9 @@
+{
+  "concept": "decorators",
+  "level": 3,
+  "title_en": "Build a retry(times) decorator factory",
+  "spec_html_en": "<p>Write decorator factory <code>retry(times)</code>. The decorated function is called up to <code>times</code> attempts, retrying whenever it raises <code>ValueError</code>. Return the first successful result; if every attempt raises <code>ValueError</code>, let the last one propagate.</p>",
+  "stub": "from functools import wraps\n\n\ndef retry(times):\n    # TODO: implement as a decorator factory per spec:\n    # retry(times) -> decorator(func) -> wrapper(*args, **kwargs)\n    ...\n",
+  "test": "def test_succeeds_on_first_try():\n    @retry(3)\n    def always_ok():\n        return 'ok'\n    assert always_ok() == 'ok', 'a function that never raises must just return its result'\n\ndef test_retries_until_success():\n    attempts = []\n\n    @retry(3)\n    def flaky():\n        attempts.append(1)\n        if len(attempts) < 2:\n            raise ValueError('not yet')\n        return 'recovered'\n\n    assert flaky() == 'recovered', 'retry must retry after a ValueError and return the eventual success'\n    assert len(attempts) == 2, 'the function must have been called exactly twice before succeeding'\n\ndef test_raises_after_exhausting_attempts():\n    @retry(2)\n    def always_fails():\n        raise ValueError('nope')\n\n    try:\n        always_fails()\n        assert False, 'retry must let the exception propagate once every attempt is exhausted'\n    except ValueError:\n        pass",
+  "canonical": "from functools import wraps\n\n\ndef retry(times):\n    def decorator(func):\n        @wraps(func)\n        def wrapper(*args, **kwargs):\n            last_error = None\n            for _ in range(times):\n                try:\n                    return func(*args, **kwargs)\n                except ValueError as e:\n                    last_error = e\n            raise last_error\n        return wrapper\n    return decorator\n"
+}

package/skills/muscle-memory/assets/library-seed/dunder-methods/card.md

@@ -0,0 +1,28 @@
+# Dunder methods (`__repr__`, `__eq__`, `__len__`, `__iter__`)
+
+## What it is
+Dunder ("double underscore") methods let your objects plug into Python's built-in syntax: `repr(obj)`, `obj1 == obj2`, `len(obj)`, `for x in obj`. Implement the ones your object's use case needs instead of writing custom `.compare()` or `.count()` methods.
+
+## Idiomatic example
+```python
+class Playlist:
+    def __init__(self, songs: list):
+        self.songs = songs
+
+    def __repr__(self) -> str:
+        return f"Playlist({self.songs!r})"
+
+    def __len__(self) -> int:
+        return len(self.songs)
+```
+
+## Common mistakes
+- Implementing `__eq__` but forgetting it changes hashability (a class with custom `__eq__` becomes unhashable unless `__hash__` is also defined).
+- Implementing `__eq__` without checking the type of the other operand — should return `NotImplemented` if the other is not the expected type, rather than raising `AttributeError`.
+- Confusing `__repr__` (unambiguous, for developers) with `__str__` (readable, for end users) — `__repr__` is the fallback if `__str__` is missing.
+- Writing `__iter__` that returns `self` without a working `__next__`, or forgetting to raise `StopIteration`.
+
+## Where you see it in real code
+- `__repr__` on every domain entity to make debugging and logs readable.
+- `__eq__`/`__hash__` on value objects so they work correctly in sets and as dict keys.
+- `__len__`/`__iter__` on custom collections (e.g. a `Batch` or `Queue` wrapper) so they behave like built-in containers.

package/skills/muscle-memory/assets/library-seed/dunder-methods/katas/l1-coordinate.json

@@ -0,0 +1,9 @@
+{
+  "concept": "dunder-methods",
+  "level": 1,
+  "title_en": "Add __repr__ and __eq__",
+  "spec_html_en": "<p>The class <code>Coordinate</code> stores <code>lat</code> and <code>lng</code>. Add <code>__repr__</code> returning <code>\"Coordinate(lat, lng)\"</code> and <code>__eq__</code> comparing both fields.</p>",
+  "stub": "class Coordinate:\n    def __init__(self, lat: float, lng: float):\n        self.lat = lat\n        self.lng = lng\n\n    # TODO: add __repr__ returning \"Coordinate(lat, lng)\" and __eq__ comparing lat and lng\n",
+  "test": "def test_repr_format():\n    c = Coordinate(40.7, -74.0)\n    assert repr(c) == 'Coordinate(40.7, -74.0)', 'repr must be Coordinate(lat, lng)'\n\ndef test_eq_same_values():\n    assert Coordinate(1.0, 2.0) == Coordinate(1.0, 2.0), 'coordinates with equal lat/lng must be equal'\n\ndef test_eq_different_values():\n    assert Coordinate(1.0, 2.0) != Coordinate(1.0, 3.0), 'coordinates with different lng must not be equal'",
+  "canonical": "class Coordinate:\n    def __init__(self, lat, lng):\n        self.lat = lat\n        self.lng = lng\n\n    def __repr__(self):\n        return f'Coordinate({self.lat}, {self.lng})'\n\n    def __eq__(self, other):\n        return self.lat == other.lat and self.lng == other.lng\n"
+}

package/skills/muscle-memory/assets/library-seed/dunder-methods/katas/l2-inventory.json

@@ -0,0 +1,9 @@
+{
+  "concept": "dunder-methods",
+  "level": 2,
+  "title_en": "Build Inventory with __len__ and __iter__",
+  "spec_html_en": "<p>Write class <code>Inventory</code> with <code>__init__(self, items)</code> storing items. Implement <code>__len__</code> returning the number of items, and <code>__iter__</code> allowing iteration over the items in order.</p>",
+  "stub": "class Inventory:\n    # TODO: implement __init__, __len__ and __iter__ per spec\n    pass\n",
+  "test": "def test_len():\n    inv = Inventory(['bolt', 'nut', 'washer'])\n    assert len(inv) == 3, 'len(inventory) must return the number of items'\n\ndef test_iter_order():\n    inv = Inventory(['bolt', 'nut'])\n    assert list(inv) == ['bolt', 'nut'], 'iterating must yield items in insertion order'\n\ndef test_empty_inventory():\n    inv = Inventory([])\n    assert len(inv) == 0, 'an empty inventory must have length 0'\n    assert list(inv) == [], 'iterating an empty inventory must yield nothing'",
+  "canonical": "class Inventory:\n    def __init__(self, items):\n        self.items = items\n\n    def __len__(self):\n        return len(self.items)\n\n    def __iter__(self):\n        return iter(self.items)\n"
+}

package/skills/muscle-memory/assets/library-seed/enums/card.md

@@ -0,0 +1,24 @@
+# `Enum`
+
+## What it is
+`Enum` gives a fixed, named set of constant values (e.g. statuses, categories) instead of scattering magic strings or numbers through the code. Each member has a name and a value, compares by identity, and can carry its own methods.
+
+## Idiomatic example
+```python
+from enum import Enum
+
+class Status(Enum):
+    PENDING = "pending"
+    SHIPPED = "shipped"
+    DELIVERED = "delivered"
+```
+
+## Common mistakes
+- Comparing an enum member to its raw value (`Status.PENDING == "pending"`) instead of to another member — by default this is `False`, since `Enum` members are not equal to plain strings unless you use `StrEnum`/mixins.
+- Reassigning or duplicating a value across members without realizing `Enum` aliases duplicates to the same member instead of erroring.
+- Using `Enum` for values that need arithmetic or ordering without inheriting from `IntEnum`, which supports comparisons.
+
+## Where you see it in real code
+- Order/ticket status fields (`PENDING`, `IN_PROGRESS`, `CLOSED`) instead of free-text strings.
+- Configuration choices (log level, environment: `DEV`, `STAGING`, `PROD`).
+- Enum methods that map a member to display text or the next valid state in a workflow.

package/skills/muscle-memory/assets/library-seed/enums/katas/l1-order-status-enum.json

@@ -0,0 +1,9 @@
+{
+  "concept": "enums",
+  "level": 1,
+  "title_en": "Fill in the Enum members",
+  "spec_html_en": "<p>Add members to <code>OrderStatus</code>: <code>PENDING = \"pending\"</code>, <code>SHIPPED = \"shipped\"</code>, <code>DELIVERED = \"delivered\"</code>.</p>",
+  "stub": "from enum import Enum\n\n\nclass OrderStatus(Enum):\n    # TODO: add members PENDING = 'pending', SHIPPED = 'shipped', DELIVERED = 'delivered'\n    ...\n",
+  "test": "def test_member_values():\n    assert OrderStatus.PENDING.value == 'pending', \"PENDING must have value 'pending'\"\n    assert OrderStatus.SHIPPED.value == 'shipped', \"SHIPPED must have value 'shipped'\"\n\ndef test_members_are_distinct():\n    assert OrderStatus.PENDING != OrderStatus.SHIPPED, 'different members must not be equal'\n\ndef test_lookup_by_value():\n    assert OrderStatus('delivered') == OrderStatus.DELIVERED, \"OrderStatus('delivered') must return DELIVERED\"",
+  "canonical": "from enum import Enum\n\n\nclass OrderStatus(Enum):\n    PENDING = 'pending'\n    SHIPPED = 'shipped'\n    DELIVERED = 'delivered'\n"
+}

package/skills/muscle-memory/assets/library-seed/enums/katas/l2-access-level.json

@@ -0,0 +1,9 @@
+{
+  "concept": "enums",
+  "level": 2,
+  "title_en": "Build an Enum with its own method",
+  "spec_html_en": "<p>Write <code>Enum</code> <code>AccessLevel</code> with members <code>GUEST = 1</code>, <code>MEMBER = 2</code>, <code>ADMIN = 3</code>. Add method <code>can_edit(self)</code> returning <code>True</code> if the member's value is 2 or higher, <code>False</code> otherwise.</p>",
+  "stub": "from enum import Enum\n\n\nclass AccessLevel(Enum):\n    # TODO: define members GUEST=1, MEMBER=2, ADMIN=3, and method can_edit() per spec\n    pass\n",
+  "test": "def test_guest_cannot_edit():\n    assert AccessLevel.GUEST.can_edit() is False, 'GUEST must not be able to edit'\n\ndef test_member_can_edit():\n    assert AccessLevel.MEMBER.can_edit() is True, 'MEMBER must be able to edit'\n\ndef test_admin_can_edit():\n    assert AccessLevel.ADMIN.can_edit() is True, 'ADMIN must be able to edit'",
+  "canonical": "from enum import Enum\n\n\nclass AccessLevel(Enum):\n    GUEST = 1\n    MEMBER = 2\n    ADMIN = 3\n\n    def can_edit(self):\n        return self.value >= 2\n"
+}

package/skills/muscle-memory/assets/library-seed/exceptions/card.md

@@ -0,0 +1,25 @@
+# Custom exceptions and `try`/`except`/`else`/`finally`
+
+## What it is
+Custom exception classes (subclassing `Exception`) let callers catch your specific error instead of a generic one. `try`/`except` handles the failure; `else` runs only if no exception was raised; `finally` always runs, for cleanup that must happen either way.
+
+## Idiomatic example
+```python
+class InsufficientFundsError(Exception):
+    pass
+
+def withdraw(balance: float, amount: float) -> float:
+    if amount > balance:
+        raise InsufficientFundsError(f"cannot withdraw {amount} from {balance}")
+    return balance - amount
+```
+
+## Common mistakes
+- Catching bare `except:` (or `except Exception:` too broadly), swallowing bugs you didn't mean to handle.
+- Raising a generic `Exception("...")` instead of a specific custom exception, forcing callers to parse the message string.
+- Putting cleanup logic in `except` instead of `finally`, so it gets skipped when no exception occurs.
+
+## Where you see it in real code
+- Domain-specific exceptions like `OutOfStockError`, `PaymentDeclinedError` that a service layer catches and maps to an HTTP status.
+- `finally` blocks that release a lock, close a connection, or roll back a transaction.
+- `else` blocks that run code only after a risky operation succeeded (e.g. logging a successful write).

package/skills/muscle-memory/assets/library-seed/exceptions/katas/l1-out-of-stock.json

@@ -0,0 +1,9 @@
+{
+  "concept": "exceptions",
+  "level": 1,
+  "title_en": "Raise a custom exception",
+  "spec_html_en": "<p>Implement <code>remove_stock(stock, quantity)</code>: raise <code>OutOfStockError</code> if <code>quantity > stock</code>, otherwise return <code>stock - quantity</code>.</p>",
+  "stub": "class OutOfStockError(Exception):\n    pass\n\n\ndef remove_stock(stock: int, quantity: int) -> int:\n    # TODO: raise OutOfStockError if quantity > stock, otherwise return stock - quantity\n    ...\n",
+  "test": "def test_removes_stock_normally():\n    assert remove_stock(10, 3) == 7, 'removing 3 from 10 must leave 7'\n\ndef test_raises_when_insufficient():\n    try:\n        remove_stock(2, 5)\n        assert False, 'removing more than available stock must raise OutOfStockError'\n    except OutOfStockError:\n        pass\n\ndef test_removes_exact_stock():\n    assert remove_stock(5, 5) == 0, 'removing all remaining stock must leave 0'",
+  "canonical": "class OutOfStockError(Exception):\n    pass\n\n\ndef remove_stock(stock, quantity):\n    if quantity > stock:\n        raise OutOfStockError(f'cannot remove {quantity} units, only {stock} in stock')\n    return stock - quantity\n"
+}

package/skills/muscle-memory/assets/library-seed/exceptions/katas/l2-parse-reading.json

@@ -0,0 +1,9 @@
+{
+  "concept": "exceptions",
+  "level": 2,
+  "title_en": "Build parse_reading with try/except/else/finally",
+  "spec_html_en": "<p>Write <code>parse_reading(raw, log)</code>. Try to convert <code>raw</code> to <code>float</code>. If it raises <code>ValueError</code>, append <code>\"invalid\"</code> to <code>log</code> and return <code>None</code>. On success, append <code>\"ok\"</code> to <code>log</code> in the <code>else</code> branch and return the parsed float. Regardless of outcome, always append <code>\"done\"</code> to <code>log</code> in a <code>finally</code> block.</p>",
+  "stub": "def parse_reading(raw: str, log: list):\n    # TODO: implement per spec using try/except/else/finally\n    ...\n",
+  "test": "def test_valid_reading():\n    log = []\n    result = parse_reading('23.5', log)\n    assert result == 23.5, 'a valid numeric string must be parsed to a float'\n    assert log == ['ok', 'done'], \"on success, log must record 'ok' then 'done'\"\n\ndef test_invalid_reading():\n    log = []\n    result = parse_reading('N/A', log)\n    assert result is None, 'an invalid reading must return None'\n    assert log == ['invalid', 'done'], \"on failure, log must record 'invalid' then 'done'\"\n\ndef test_finally_always_runs():\n    log = []\n    parse_reading('1', log)\n    parse_reading('x', log)\n    assert log.count('done') == 2, \"'done' must be appended on every call, success or failure\"",
+  "canonical": "def parse_reading(raw, log):\n    try:\n        value = float(raw)\n    except ValueError:\n        log.append('invalid')\n        return None\n    else:\n        log.append('ok')\n        return value\n    finally:\n        log.append('done')\n"
+}

package/skills/muscle-memory/assets/library-seed/factory/card.md

@@ -0,0 +1,24 @@
+# Factory
+
+## What it is
+The Factory pattern hides *how* an object gets constructed behind a function or method: callers ask for "a thing that does X" by name/key, instead of importing and instantiating a concrete class directly. A simple factory is a function that switches on a key; a registry-based factory keeps a dict mapping keys to constructors, so new types register themselves instead of the factory function growing an `if/elif` chain forever.
+
+## Idiomatic example
+```python
+def create_shape(kind, **kwargs):
+    if kind == 'circle':
+        return Circle(**kwargs)
+    if kind == 'square':
+        return Square(**kwargs)
+    raise ValueError(f'unknown shape: {kind}')
+```
+
+## Common mistakes
+- Growing an ever-longer `if/elif` chain instead of switching to a registry dict once the number of cases grows.
+- Forgetting the final `else`/`raise` branch, so an unknown key silently returns `None` instead of failing loudly.
+- Coupling the factory to concrete classes directly (`Circle`, `Square` imported everywhere) instead of letting the caller depend only on the factory function's return type/interface.
+
+## Where you see it in real code
+- ORMs and serializers picking a field/column type from a string tag (`"varchar"`, `"integer"`).
+- Plugin systems where each plugin registers itself under a name at import time (`@register('slack')`).
+- Parser/exporter libraries choosing an implementation from a file extension or content-type string.

package/skills/muscle-memory/assets/library-seed/factory/katas/l2-exporter-factory.json

@@ -0,0 +1,9 @@
+{
+  "concept": "factory",
+  "level": 2,
+  "title_en": "Build a create_exporter(kind) function factory",
+  "spec_html_en": "<p>Write function <code>create_exporter(kind)</code> that returns a formatter function chosen by <code>kind</code>: for <code>\"csv\"</code> return a function that joins a row (a list of values) with commas; for <code>\"json\"</code> return a function that returns <code>json.dumps(row)</code>. Raise <code>ValueError</code> for any other <code>kind</code>.</p>",
+  "stub": "import json\n\n\ndef create_exporter(kind):\n    # TODO: implement per spec: return a formatter function for 'csv' or 'json',\n    # raise ValueError for anything else\n    ...\n",
+  "test": "def test_csv_exporter_joins_values():\n    exporter = create_exporter('csv')\n    assert exporter(['Ana', 30]) == 'Ana,30', 'the csv exporter must join row values with commas'\n\ndef test_json_exporter_dumps_row():\n    exporter = create_exporter('json')\n    assert exporter(['Ana', 30]) == '[\"Ana\", 30]', 'the json exporter must return the row as a JSON string'\n\ndef test_unknown_kind_raises():\n    try:\n        create_exporter('xml')\n        assert False, 'an unknown exporter kind must raise ValueError'\n    except ValueError:\n        pass\n",
+  "canonical": "import json\n\n\ndef create_exporter(kind):\n    if kind == 'csv':\n        return lambda row: ','.join(str(v) for v in row)\n    if kind == 'json':\n        return lambda row: json.dumps(row)\n    raise ValueError(f'unknown exporter kind: {kind}')\n"
+}

package/skills/muscle-memory/assets/library-seed/factory/katas/l3-payment-registry.json

@@ -0,0 +1,9 @@
+{
+  "concept": "factory",
+  "level": 3,
+  "title_en": "Build a registry-based create_processor factory",
+  "spec_html_en": "<p>Write function <code>create_processor(name, *args, **kwargs)</code> for a registry-based factory. Classes are registered into the <code>PROCESSORS</code> dict via the already-implemented <code>@register(name)</code> class decorator. <code>create_processor</code> must look up <code>name</code> in <code>PROCESSORS</code> and instantiate the matching class with the given <code>args</code>/<code>kwargs</code>, raising <code>KeyError</code> if <code>name</code> was never registered.</p>",
+  "stub": "PROCESSORS = {}\n\n\ndef register(name):\n    def decorator(cls):\n        PROCESSORS[name] = cls\n        return cls\n    return decorator\n\n\ndef create_processor(name, *args, **kwargs):\n    # TODO: implement per spec: look up name in PROCESSORS and instantiate it,\n    # raising KeyError if name is not registered\n    ...\n\n\n@register('card')\nclass CardProcessor:\n    def charge(self, amount):\n        return f'charged {amount} via card'\n\n\n@register('paypal')\nclass PaypalProcessor:\n    def charge(self, amount):\n        return f'charged {amount} via paypal'\n",
+  "test": "def test_creates_registered_card_processor():\n    processor = create_processor('card')\n    assert processor.charge(100) == 'charged 100 via card', 'create_processor must instantiate the class registered under \"card\"'\n\ndef test_creates_registered_paypal_processor():\n    processor = create_processor('paypal')\n    assert processor.charge(50) == 'charged 50 via paypal', 'create_processor must instantiate the class registered under \"paypal\"'\n\ndef test_unregistered_name_raises():\n    try:\n        create_processor('bitcoin')\n        assert False, 'requesting an unregistered processor name must raise KeyError'\n    except KeyError:\n        pass\n",
+  "canonical": "PROCESSORS = {}\n\n\ndef register(name):\n    def decorator(cls):\n        PROCESSORS[name] = cls\n        return cls\n    return decorator\n\n\ndef create_processor(name, *args, **kwargs):\n    if name not in PROCESSORS:\n        raise KeyError(f'no processor registered for {name!r}')\n    return PROCESSORS[name](*args, **kwargs)\n\n\n@register('card')\nclass CardProcessor:\n    def charge(self, amount):\n        return f'charged {amount} via card'\n\n\n@register('paypal')\nclass PaypalProcessor:\n    def charge(self, amount):\n        return f'charged {amount} via paypal'\n"
+}