Fix insert_key_between bug with nested structures

Fixes bug where inserting after a key with deeply nested values would
incorrectly move the last item from the nested structure into the new
key's value.

**The Problem:**
_find_key_byte_range() was only looking one level deep when finding the
end of nested structures. For example, with:
```yaml
strategy:
  matrix:
    python-version: ["3.11"]
    jax-version: ["0.5.2", "0.6.2"]
```

It would find the end at `python-version` line instead of `jax-version`
line, causing `jax-version` to be incorrectly captured and moved into
the next inserted key.

**The Fix:**
Added recursive `find_last_line()` helper that traverses nested
CommentedMaps and CommentedSeqs to find the actual last line of deeply
nested structures.

**Test:**
Added regression test that verifies:
- strategy.matrix keeps both python-version and jax-version
- defaults.run only has working-directory
- jax-version doesn't leak into defaults.run

All 38 tests passing ✅

This fixes the workspace migration issue where strategy.matrix values
were being corrupted when adding defaults sections.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ryan-williams

src/yaya/document.py

@@ -372,24 +372,45 @@ def _find_key_byte_range(self, parent: CommentedMap, key: str) -> tuple[int, int
         val_start, val_end = find_scalar_value_range(self.original_bytes, val_line, val_col)
 
         # For non-scalar values (maps, sequences), we need to find the actual end
+        # by recursively finding the last item in nested structures
         value = parent[key]
         if isinstance(value, (CommentedMap, CommentedSeq)):
-            # Find the end by looking for the last item's position
             val_end_line = val_line
-            if hasattr(value, 'lc') and hasattr(value.lc, 'data'):
-                # Get the last item's position
-                if isinstance(value, CommentedMap) and value:
-                    last_key = list(value.keys())[-1]
-                    if last_key in value.lc.data:
-                        last_info = value.lc.data[last_key]
+
+            # Recursively find the deepest last item
+            def find_last_line(obj):
+                """Recursively find the line number of the last item in nested structures."""
+                if isinstance(obj, CommentedMap) and obj and hasattr(obj, 'lc'):
+                    last_key = list(obj.keys())[-1]
+                    if last_key in obj.lc.data:
+                        last_info = obj.lc.data[last_key]
                         if len(last_info) >= 4:
-                            val_end_line = last_info[2]
-                elif isinstance(value, CommentedSeq) and value:
-                    last_idx = len(value) - 1
-                    if last_idx in value.lc.data:
-                        last_info = value.lc.data[last_idx]
+                            # Check if the value is also nested
+                            last_value = obj[last_key]
+                            if isinstance(last_value, (CommentedMap, CommentedSeq)):
+                                # Recurse into nested structure
+                                return find_last_line(last_value)
+                            else:
+                                # Scalar value - return its line
+                                return last_info[2]
+                elif isinstance(obj, CommentedSeq) and obj and hasattr(obj, 'lc'):
+                    last_idx = len(obj) - 1
+                    if last_idx in obj.lc.data:
+                        last_info = obj.lc.data[last_idx]
                         if len(last_info) >= 2:
-                            val_end_line = last_info[0]
+                            # Check if the item is also nested
+                            last_item = obj[last_idx]
+                            if isinstance(last_item, (CommentedMap, CommentedSeq)):
+                                # Recurse into nested structure
+                                return find_last_line(last_item)
+                            else:
+                                # Scalar item - return its line
+                                return last_info[0]
+                return None
+
+            last_line = find_last_line(value)
+            if last_line is not None:
+                val_end_line = last_line
 
             # Find end of that line
             val_end = line_col_to_index(self.original_bytes, val_end_line, 0)

tests/test_ordered_insertions.py

@@ -89,3 +89,50 @@ def test_insert_key_between_missing_key(tmp_path):
             new_key="new",
             value=42
         )
+
+
+def test_insert_key_between_with_nested_prev_key(tmp_path):
+    """
+    Test that insert_key_between correctly handles prev_key with nested structures.
+
+    Regression test for bug where the last item from a nested structure would
+    get incorrectly moved into the newly inserted key's value.
+    """
+    yaml_file = tmp_path / "test.yaml"
+    yaml_file.write_text("""jobs:
+  unit_tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11"]
+        jax-version: ["0.5.2", "0.6.2"]
+    steps:
+      - run: echo test
+""")
+
+    doc = YAYA.load(yaml_file)
+
+    # Insert defaults between strategy (which has nested content) and steps
+    doc.insert_key_between(
+        "jobs.unit_tests",
+        prev_key="strategy",
+        next_key="steps",
+        new_key="defaults",
+        value={"run": {"working-directory": "lib/levanter"}}
+    )
+
+    doc.save()
+
+    # Verify the structure is correct
+    doc2 = YAYA.load(yaml_file)
+
+    # strategy.matrix should still have both keys
+    matrix_keys = list(doc2.get_path('jobs.unit_tests.strategy.matrix').keys())
+    assert matrix_keys == ['python-version', 'jax-version']
+
+    # defaults.run should only have working-directory
+    defaults_run_keys = list(doc2.get_path('jobs.unit_tests.defaults.run').keys())
+    assert defaults_run_keys == ['working-directory']
+
+    # Verify jax-version wasn't moved
+    assert 'jax-version' not in doc2.get_path('jobs.unit_tests.defaults.run')