rhiza 0.8.0__tar.gz → 0.8.2__tar.gz

{rhiza-0.8.0 → rhiza-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhiza
-Version: 0.8.0
+Version: 0.8.2
 Summary: Reusable configuration templates for modern Python projects
 Project-URL: Homepage, https://github.com/jebel-quant/rhiza-cli
 Project-URL: Repository, https://github.com/jebel-quant/rhiza-cli

{rhiza-0.8.0 → rhiza-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rhiza"
-version = "0.8.0"
+version = "0.8.2"
 description = "Reusable configuration templates for modern Python projects"
 readme = "README.md"
 requires-python = ">=3.11"

{rhiza-0.8.0 → rhiza-0.8.2}/src/rhiza/commands/init.py

@@ -85,6 +85,7 @@ def init(
             template_repository="jebel-quant/rhiza",
             template_branch="main",
             include=[
+                ".rhiza",  # .rhiza folder
                 ".github",  # GitHub configuration and workflows
                 ".editorconfig",  # Editor configuration
                 ".gitignore",  # Git ignore patterns

{rhiza-0.8.0 → rhiza-0.8.2}/src/rhiza/commands/materialize.py

@@ -15,7 +15,7 @@ from pathlib import Path
 
 from loguru import logger
 
-from rhiza.commands import init
+from rhiza.commands.validate import validate
 from rhiza.models import RhizaTemplate
 
 
@@ -116,11 +116,11 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
             sys.exit(1)
 
     # -----------------------
-    # Ensure Rhiza is initialized
+    # Validate Rhiza configuration
     # -----------------------
-    # The init function creates template.yml if missing and validates it
+    # The validate function checks if template.yml exists and is valid
     # Returns True if valid, False otherwise
-    valid = init(target)
+    valid = validate(target)
 
     if not valid:
         logger.error(f"Rhiza template is invalid in: {target}")
@@ -128,21 +128,8 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         sys.exit(1)
 
     # Load the template configuration from the validated file
-    # Check for template in new location first, then fall back to old location
-    migrated_template_file = target / ".rhiza" / "template.yml"
-    standard_template_file = target / ".github" / "rhiza" / "template.yml"
-
-    if migrated_template_file.exists():
-        template_file = migrated_template_file
-        logger.debug(f"Loading template configuration from migrated location: {template_file}")
-    elif standard_template_file.exists():
-        template_file = standard_template_file
-        logger.debug(f"Loading template configuration from standard location: {template_file}")
-    else:
-        logger.error("No template.yml file found")
-        logger.error("Run 'rhiza init' or 'rhiza migrate' to create one")
-        sys.exit(1)
-
+    # Validation ensures the file exists at .rhiza/template.yml
+    template_file = target / ".rhiza" / "template.yml"
     template = RhizaTemplate.from_yaml(template_file)
 
     # Extract template configuration settings

{rhiza-0.8.0 → rhiza-0.8.2}/src/rhiza/commands/migrate.py

@@ -10,6 +10,8 @@ from pathlib import Path
 
 from loguru import logger
 
+from rhiza.models import RhizaTemplate
+
 
 def migrate(target: Path) -> None:
     """Migrate project to use the new .rhiza folder structure.
@@ -81,6 +83,23 @@ def migrate(target: Path) -> None:
             logger.warning("No existing template.yml file found in .github")
             logger.info("You may need to run 'rhiza init' to create a template configuration")
 
+    # Ensure the .rhiza folder is included in template.yml include list (if template exists)
+    template_file = new_template_file
+    if template_file.exists():
+        # Load existing template configuration
+        template = RhizaTemplate.from_yaml(template_file)
+        template_include = template.include or []
+        if ".rhiza" not in template_include:
+            logger.warning("The .rhiza folder is not included in your template.yml")
+            template_include.append(".rhiza")
+            logger.info("The .rhiza folder is added to your template.yml to ensure it's included in your repository")
+
+            # Save the updated template.yml
+            template.include = template_include
+            template.to_yaml(template_file)
+    else:
+        logger.debug("No template.yml present in .rhiza; skipping include update")
+
     # Migrate .rhiza.history to .rhiza/history if it exists
     old_history_file = target / ".rhiza.history"
     new_history_file = rhiza_dir / "history"

{rhiza-0.8.0 → rhiza-0.8.2}/tests/test_commands/test_materialize.py

@@ -5,6 +5,7 @@ underlying inject logic and that basic paths and options are handled.
 """
 
 import subprocess
+from pathlib import Path
 from unittest.mock import Mock, patch
 
 import pytest
@@ -18,41 +19,20 @@ from rhiza.commands.materialize import materialize
 class TestInjectCommand:
     """Tests for the inject/materialize command."""
 
-    @patch("rhiza.commands.materialize.subprocess.run")
-    @patch("rhiza.commands.materialize.shutil.rmtree")
-    @patch("rhiza.commands.materialize.shutil.copy2")
-    @patch("rhiza.commands.materialize.tempfile.mkdtemp")
-    def test_inject_creates_default_template_yml(
-        self, mock_mkdtemp, mock_copy2, mock_rmtree, mock_subprocess, tmp_path
-    ):
-        """Test that inject creates a default template.yml when it doesn't exist."""
+    def test_inject_fails_without_template_yml(self, tmp_path):
+        """Test that materialize fails when template.yml doesn't exist."""
         # Setup git repo
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
-        # Mock tempfile to return a controlled temp directory
-        temp_dir = tmp_path / "temp"
-        temp_dir.mkdir()
-        mock_mkdtemp.return_value = str(temp_dir)
-
-        # Mock subprocess to succeed
-        mock_subprocess.return_value = Mock(returncode=0)
+        # Create required pyproject.toml (needed for validation to not fail earlier)
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text("[project]\nname = 'test'\n")
 
-        # Run inject
-        materialize(tmp_path, "main", None, False)
-
-        # Verify template.yml was created
-        template_file = tmp_path / ".rhiza" / "template.yml"
-        assert template_file.exists()
-
-        # Verify it contains expected content
-
-        with open(template_file) as f:
-            config = yaml.safe_load(f)
-
-        assert config["template-repository"] == "jebel-quant/rhiza"
-        assert config["template-branch"] == "main"
-        assert ".github" in config["include"]
+        # Run materialize without creating template.yml first
+        # It should fail because template.yml doesn't exist
+        with pytest.raises(SystemExit):
+            materialize(tmp_path, "main", None, False)
 
     @patch("rhiza.commands.materialize.subprocess.run")
     @patch("rhiza.commands.materialize.shutil.rmtree")
@@ -64,6 +44,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create existing template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -99,6 +83,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml with empty include
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -121,6 +109,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -159,6 +151,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create existing file in target
         existing_file = tmp_path / "test.txt"
         existing_file.write_text("existing")
@@ -201,6 +197,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create existing file in target
         existing_file = tmp_path / "test.txt"
         existing_file.write_text("existing")
@@ -241,6 +241,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml with exclude
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -289,6 +293,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create minimal template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -320,6 +328,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -354,6 +366,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -410,6 +426,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create existing file that will be skipped
         existing_file = tmp_path / "existing.txt"
         existing_file.write_text("existing content")
@@ -460,6 +480,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml with gitlab host
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -509,6 +533,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml with explicit github host
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -550,6 +578,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml with invalid host
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -587,6 +619,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create src and tests folders to avoid validation warnings
         (tmp_path / "src").mkdir()
         (tmp_path / "tests").mkdir()
@@ -630,13 +666,17 @@ class TestInjectCommand:
             assert "workflow" in call_args.lower()
             assert "permission" in call_args.lower()
 
-    @patch("rhiza.commands.materialize.init")
-    def test_materialize_empty_include_paths_raises_error(self, mock_init, tmp_path):
+    @patch("rhiza.commands.materialize.validate")
+    def test_materialize_raises_error_when_validate_bypassed_with_empty_include(self, mock_validate, tmp_path):
         """Test that materialize raises RuntimeError when include_paths is empty after validation."""
         # Setup git repo
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml with empty include (bypassing normal validation)
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -652,8 +692,10 @@ class TestInjectCommand:
                 f,
             )
 
-        # Mock init to return True (bypass validation that would catch this)
-        mock_init.return_value = True
+        # Mock validate to return True to bypass normal validation that would catch empty include lists.
+        # This test validates materialize's runtime error handling for the theoretical edge case
+        # where validation passes but include_paths is still empty (e.g., validation logic gaps).
+        mock_validate.return_value = True
 
         # Run materialize and expect RuntimeError
         with pytest.raises(RuntimeError, match="No include paths found"):
@@ -669,6 +711,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -726,6 +772,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -780,6 +830,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -825,6 +879,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -864,6 +922,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -898,6 +960,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -951,6 +1017,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create template.yml
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -1009,6 +1079,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create an old .rhiza/history file with files that will become orphaned
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -1082,6 +1156,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create an old .rhiza/history file with a file that doesn't exist
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -1143,6 +1221,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # No old .rhiza/history file
 
         # Create template.yml
@@ -1193,6 +1275,10 @@ class TestInjectCommand:
         git_dir = tmp_path / ".git"
         git_dir.mkdir()
 
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
         # Create .rhiza/history with a file that will be orphaned
         rhiza_dir = tmp_path / ".rhiza"
         rhiza_dir.mkdir(parents=True, exist_ok=True)
@@ -1235,3 +1321,185 @@ class TestInjectCommand:
 
         # Verify the file still exists (deletion failed but was handled)
         assert old_file.exists()
+
+    @patch("rhiza.commands.materialize.subprocess.run")
+    @patch("rhiza.commands.materialize.shutil.rmtree")
+    @patch("rhiza.commands.materialize.shutil.copy2")
+    @patch("rhiza.commands.materialize.tempfile.mkdtemp")
+    def test_materialize_with_legacy_history_location(
+        self, mock_mkdtemp, mock_copy2, mock_rmtree, mock_subprocess, tmp_path
+    ):
+        """Test that materialize reads history from legacy .rhiza.history location."""
+        # Setup git repo
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
+        # Create old .rhiza.history file (legacy location at root)
+        old_history_file = tmp_path / ".rhiza.history"
+        old_history_file.write_text("old_file.txt\n")
+
+        # Create the file that was in history
+        old_file = tmp_path / "old_file.txt"
+        old_file.write_text("old content")
+
+        # Create template.yml
+        rhiza_dir = tmp_path / ".rhiza"
+        rhiza_dir.mkdir(parents=True, exist_ok=True)
+        template_file = rhiza_dir / "template.yml"
+
+        with open(template_file, "w") as f:
+            yaml.dump(
+                {
+                    "template-repository": "jebel-quant/rhiza",
+                    "template-branch": "main",
+                    "include": ["new_file.txt"],
+                },
+                f,
+            )
+
+        # Mock tempfile
+        temp_dir = tmp_path / "temp"
+        temp_dir.mkdir()
+        new_file = temp_dir / "new_file.txt"
+        new_file.write_text("new content")
+        mock_mkdtemp.return_value = str(temp_dir)
+
+        # Mock subprocess to succeed
+        mock_subprocess.return_value = Mock(returncode=0)
+
+        # Run materialize - should read from legacy location and delete orphaned file
+        materialize(tmp_path, "main", None, False)
+
+        # Verify old file was deleted (it was in old history but not in new template)
+        assert not old_file.exists()
+
+        # Verify new history file was created in new location
+        new_history_file = tmp_path / ".rhiza" / "history"
+        assert new_history_file.exists()
+
+    @patch("rhiza.commands.materialize.subprocess.run")
+    @patch("rhiza.commands.materialize.shutil.rmtree")
+    @patch("rhiza.commands.materialize.shutil.copy2")
+    @patch("rhiza.commands.materialize.tempfile.mkdtemp")
+    def test_materialize_cleans_up_legacy_history_file(
+        self, mock_mkdtemp, mock_copy2, mock_rmtree, mock_subprocess, tmp_path
+    ):
+        """Test that materialize removes old .rhiza.history after migration."""
+        # Setup git repo
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
+        # Create both old and new history files
+        old_history_file = tmp_path / ".rhiza.history"
+        old_history_file.write_text("file1.txt\n")
+
+        rhiza_dir = tmp_path / ".rhiza"
+        rhiza_dir.mkdir(parents=True, exist_ok=True)
+        new_history_file = rhiza_dir / "history"
+        new_history_file.write_text("file1.txt\n")
+
+        # Create template.yml
+        template_file = rhiza_dir / "template.yml"
+
+        with open(template_file, "w") as f:
+            yaml.dump(
+                {
+                    "template-repository": "jebel-quant/rhiza",
+                    "template-branch": "main",
+                    "include": ["file1.txt"],
+                },
+                f,
+            )
+
+        # Mock tempfile
+        temp_dir = tmp_path / "temp"
+        temp_dir.mkdir()
+        file1 = temp_dir / "file1.txt"
+        file1.write_text("content1")
+        mock_mkdtemp.return_value = str(temp_dir)
+
+        # Mock subprocess to succeed
+        mock_subprocess.return_value = Mock(returncode=0)
+
+        # Run materialize
+        materialize(tmp_path, "main", None, False)
+
+        # Verify old history file was removed
+        assert not old_history_file.exists()
+
+        # Verify new history file still exists
+        assert new_history_file.exists()
+
+    @patch("rhiza.commands.materialize.subprocess.run")
+    @patch("rhiza.commands.materialize.shutil.rmtree")
+    @patch("rhiza.commands.materialize.shutil.copy2")
+    @patch("rhiza.commands.materialize.tempfile.mkdtemp")
+    def test_materialize_handles_legacy_history_cleanup_failure(
+        self, mock_mkdtemp, mock_copy2, mock_rmtree, mock_subprocess, tmp_path
+    ):
+        """Test that materialize handles failure to remove old .rhiza.history gracefully."""
+        # Setup git repo
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+
+        # Create pyproject.toml for validation
+        pyproject_file = tmp_path / "pyproject.toml"
+        pyproject_file.write_text('[project]\nname = "test"\n')
+
+        # Create both old and new history files
+        old_history_file = tmp_path / ".rhiza.history"
+        old_history_file.write_text("file1.txt\n")
+
+        rhiza_dir = tmp_path / ".rhiza"
+        rhiza_dir.mkdir(parents=True, exist_ok=True)
+        new_history_file = rhiza_dir / "history"
+        new_history_file.write_text("file1.txt\n")
+
+        # Create template.yml
+        template_file = rhiza_dir / "template.yml"
+
+        with open(template_file, "w") as f:
+            yaml.dump(
+                {
+                    "template-repository": "jebel-quant/rhiza",
+                    "template-branch": "main",
+                    "include": ["file1.txt"],
+                },
+                f,
+            )
+
+        # Mock tempfile
+        temp_dir = tmp_path / "temp"
+        temp_dir.mkdir()
+        file1 = temp_dir / "file1.txt"
+        file1.write_text("content1")
+        mock_mkdtemp.return_value = str(temp_dir)
+
+        # Mock subprocess to succeed
+        mock_subprocess.return_value = Mock(returncode=0)
+
+        # Mock unlink to fail for the old history file
+        original_unlink = Path.unlink
+
+        def selective_unlink(self, *args, **kwargs):
+            if self.name == ".rhiza.history":
+                raise PermissionError("Cannot delete old history file")
+            return original_unlink(self, *args, **kwargs)
+
+        with patch.object(Path, "unlink", selective_unlink):
+            # Run materialize - should handle cleanup failure gracefully
+            materialize(tmp_path, "main", None, False)
+
+        # Verify old history file still exists (cleanup failed but was handled)
+        assert old_history_file.exists()
+
+        # Verify new history file was still created
+        assert new_history_file.exists()

{rhiza-0.8.0 → rhiza-0.8.2}/tests/test_commands/test_migrate.py

@@ -52,7 +52,8 @@ class TestMigrateCommand:
 
         assert migrated_content["template-repository"] == "test/repo"
         assert migrated_content["template-branch"] == "main"
-        assert migrated_content["include"] == [".github", "Makefile"]
+        # After migration, .rhiza should be automatically added to include list
+        assert migrated_content["include"] == [".github", "Makefile", ".rhiza"]
 
         # Verify old file was removed
         assert not old_template_file.exists()
@@ -167,6 +168,50 @@ Makefile
         new_history_file = rhiza_dir / "history"
         assert not new_history_file.exists()
 
+    def test_migrate_skips_history_when_both_exist(self, tmp_path):
+        """Test that migrate skips history migration when both old and new exist."""
+        # Create existing .rhiza.history
+        old_history_file = tmp_path / ".rhiza.history"
+        old_content = "# Old history content\nold_file.txt\n"
+        old_history_file.write_text(old_content)
+
+        # Create existing .rhiza/history (already migrated)
+        rhiza_dir = tmp_path / ".rhiza"
+        rhiza_dir.mkdir(parents=True)
+        new_history_file = rhiza_dir / "history"
+        new_content = "# New history content\nnew_file.txt\n"
+        new_history_file.write_text(new_content)
+
+        # Run migrate
+        migrate(tmp_path)
+
+        # Verify new history file was NOT overwritten
+        assert new_history_file.read_text() == new_content
+
+        # Verify old file still exists (not removed since target exists)
+        assert old_history_file.exists()
+        assert old_history_file.read_text() == old_content
+
+    def test_migrate_handles_existing_rhiza_history(self, tmp_path):
+        """Test that migrate handles when .rhiza/history already exists but .rhiza.history doesn't."""
+        # Create existing .rhiza/history (no old file)
+        rhiza_dir = tmp_path / ".rhiza"
+        rhiza_dir.mkdir(parents=True)
+        new_history_file = rhiza_dir / "history"
+        existing_content = "# Existing history\nfile.txt\n"
+        new_history_file.write_text(existing_content)
+
+        # Run migrate without creating .rhiza.history
+        migrate(tmp_path)
+
+        # Verify .rhiza/history is unchanged
+        assert new_history_file.exists()
+        assert new_history_file.read_text() == existing_content
+
+        # Verify no old file was created
+        old_history_file = tmp_path / ".rhiza.history"
+        assert not old_history_file.exists()
+
     def test_migrate_skips_existing_files(self, tmp_path):
         """Test that migrate skips existing files in .rhiza."""
         # Create existing .rhiza/template.yml
@@ -195,6 +240,92 @@ Makefile
 
         assert content["template-repository"] == "existing/repo"
 
+    def test_migrate_adds_rhiza_to_include_list(self, tmp_path):
+        """Test that migrate adds .rhiza to include list if not present."""
+        # Create existing template.yml in .github/rhiza/ without .rhiza in include
+        github_rhiza_dir = tmp_path / ".github" / "rhiza"
+        github_rhiza_dir.mkdir(parents=True)
+        old_template_file = github_rhiza_dir / "template.yml"
+
+        template_content = {
+            "template-repository": "test/repo",
+            "template-branch": "main",
+            "include": [".github", "Makefile"],
+        }
+
+        with open(old_template_file, "w") as f:
+            yaml.dump(template_content, f)
+
+        # Run migrate
+        migrate(tmp_path)
+
+        # Verify new template.yml was created
+        new_template_file = tmp_path / ".rhiza" / "template.yml"
+        assert new_template_file.exists()
+
+        # Verify .rhiza was added to include list
+        with open(new_template_file) as f:
+            migrated_content = yaml.safe_load(f)
+
+        assert ".rhiza" in migrated_content["include"]
+        assert migrated_content["include"] == [".github", "Makefile", ".rhiza"]
+
+    def test_migrate_does_not_duplicate_rhiza_in_include_list(self, tmp_path):
+        """Test that migrate does not duplicate .rhiza if already in include list."""
+        # Create existing template.yml in .github/rhiza/ with .rhiza already in include
+        github_rhiza_dir = tmp_path / ".github" / "rhiza"
+        github_rhiza_dir.mkdir(parents=True)
+        old_template_file = github_rhiza_dir / "template.yml"
+
+        template_content = {
+            "template-repository": "test/repo",
+            "template-branch": "main",
+            "include": [".github", ".rhiza", "Makefile"],
+        }
+
+        with open(old_template_file, "w") as f:
+            yaml.dump(template_content, f)
+
+        # Run migrate
+        migrate(tmp_path)
+
+        # Verify new template.yml was created
+        new_template_file = tmp_path / ".rhiza" / "template.yml"
+        assert new_template_file.exists()
+
+        # Verify .rhiza appears only once in include list
+        with open(new_template_file) as f:
+            migrated_content = yaml.safe_load(f)
+
+        assert migrated_content["include"].count(".rhiza") == 1
+        assert migrated_content["include"] == [".github", ".rhiza", "Makefile"]
+
+    def test_migrate_adds_rhiza_to_existing_template(self, tmp_path):
+        """Test that migrate adds .rhiza to include list for existing .rhiza/template.yml."""
+        # Create existing template.yml directly in .rhiza/ without .rhiza in include
+        rhiza_dir = tmp_path / ".rhiza"
+        rhiza_dir.mkdir(parents=True)
+        template_file = rhiza_dir / "template.yml"
+
+        template_content = {
+            "template-repository": "test/repo",
+            "template-branch": "main",
+            "include": ["src", "tests"],
+        }
+
+        with open(template_file, "w") as f:
+            yaml.dump(template_content, f)
+
+        # Run migrate
+        migrate(tmp_path)
+
+        # Verify .rhiza was added to include list
+        with open(template_file) as f:
+            updated_content = yaml.safe_load(f)
+
+        assert ".rhiza" in updated_content["include"]
+        assert updated_content["include"] == ["src", "tests", ".rhiza"]
+
 
 class TestMigrateCLI:
     """Tests for the migrate CLI command."""

{rhiza-0.8.0 → rhiza-0.8.2}/uv.lock

@@ -771,7 +771,7 @@ wheels = [
 
 [[package]]
 name = "rhiza"
-version = "0.8.0"
+version = "0.8.2"
 source = { editable = "." }
 dependencies = [
     { name = "jinja2" },