rhiza 0.8.3__py3-none-any.whl → 0.8.4__py3-none-any.whl

rhiza/commands/materialize.py

@@ -17,128 +17,81 @@ from loguru import logger
 
 from rhiza.commands.validate import validate
 from rhiza.models import RhizaTemplate
+from rhiza.subprocess_utils import get_git_executable
 
 
-def __expand_paths(base_dir: Path, paths: list[str]) -> list[Path]:
-    """Expand files/directories relative to base_dir into a flat list of files.
-
-    Given a list of paths relative to ``base_dir``, return a flat list of all
-    individual files.
-
-    Args:
-        base_dir: The base directory to resolve paths against.
-        paths: List of relative path strings (files or directories).
-
-    Returns:
-        A flat list of Path objects representing all individual files found.
-    """
-    all_files = []
-    for p in paths:
-        full_path = base_dir / p
-        # Check if the path is a regular file
-        if full_path.is_file():
-            all_files.append(full_path)
-        # If it's a directory, recursively find all files within it
-        elif full_path.is_dir():
-            all_files.extend([f for f in full_path.rglob("*") if f.is_file()])
-        else:
-            # Path does not exist in the cloned repository - skip it silently
-            # This can happen if the template repo doesn't have certain paths
-            logger.debug(f"Path not found in template repository: {p}")
-            continue
-    return all_files
-
-
-def materialize(target: Path, branch: str, target_branch: str | None, force: bool) -> None:
-    """Materialize Rhiza templates into the target repository.
-
-    This performs a sparse checkout of the template repository and copies the
-    selected files into the target repository, recording all files under
-    template control in `.rhiza/history`.
+def _handle_target_branch(
+    target: Path, target_branch: str | None, git_executable: str, git_env: dict[str, str]
+) -> None:
+    """Handle target branch creation or checkout if specified.
 
     Args:
-        target (Path): Path to the target repository.
-        branch (str): The Rhiza template branch to use.
-        target_branch (str | None): Optional branch name to create/checkout in
-            the target repository.
-        force (bool): Whether to overwrite existing files.
+        target: Path to the target repository.
+        target_branch: Optional branch name to create/checkout.
+        git_executable: Path to git executable.
+        git_env: Environment variables for git commands.
     """
-    # Resolve to absolute path to avoid any ambiguity
-    target = target.resolve()
-
-    logger.info(f"Target repository: {target}")
-    logger.info(f"Rhiza branch: {branch}")
+    if not target_branch:
+        return
 
-    # Set environment to prevent git from prompting for credentials
-    # This ensures non-interactive behavior during git operations
-    git_env = os.environ.copy()
-    git_env["GIT_TERMINAL_PROMPT"] = "0"
+    logger.info(f"Creating/checking out target branch: {target_branch}")
+    try:
+        # Check if branch already exists using git rev-parse
+        result = subprocess.run(
+            [git_executable, "rev-parse", "--verify", target_branch],
+            cwd=target,
+            capture_output=True,
+            text=True,
+            env=git_env,
+        )
 
-    # -----------------------
-    # Handle target branch creation/checkout if specified
-    # -----------------------
-    # When a target branch is specified, we either checkout an existing branch
-    # or create a new one. This allows users to materialize templates onto a
-    # separate branch for review before merging to main.
-    if target_branch:
-        logger.info(f"Creating/checking out target branch: {target_branch}")
-        try:
-            # Check if branch already exists using git rev-parse
-            # Returns 0 if the branch exists, non-zero otherwise
-            result = subprocess.run(
-                ["git", "rev-parse", "--verify", target_branch],
+        if result.returncode == 0:
+            # Branch exists, switch to it
+            logger.info(f"Branch '{target_branch}' exists, checking out...")
+            subprocess.run(
+                [git_executable, "checkout", target_branch],
                 cwd=target,
-                capture_output=True,
-                text=True,
+                check=True,
                 env=git_env,
             )
+        else:
+            # Branch doesn't exist, create it from current HEAD
+            logger.info(f"Creating new branch '{target_branch}'...")
+            subprocess.run(
+                [git_executable, "checkout", "-b", target_branch],
+                cwd=target,
+                check=True,
+                env=git_env,
+            )
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to create/checkout branch '{target_branch}': {e}")
+        sys.exit(1)
 
-            if result.returncode == 0:
-                # Branch exists, switch to it
-                logger.info(f"Branch '{target_branch}' exists, checking out...")
-                subprocess.run(
-                    ["git", "checkout", target_branch],
-                    cwd=target,
-                    check=True,
-                    env=git_env,
-                )
-            else:
-                # Branch doesn't exist, create it from current HEAD
-                logger.info(f"Creating new branch '{target_branch}'...")
-                subprocess.run(
-                    ["git", "checkout", "-b", target_branch],
-                    cwd=target,
-                    check=True,
-                    env=git_env,
-                )
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Failed to create/checkout branch '{target_branch}': {e}")
-            sys.exit(1)
-
-    # -----------------------
+
+def _validate_and_load_template(target: Path, branch: str) -> tuple[RhizaTemplate, str, str, list[str], list[str]]:
+    """Validate configuration and load template settings.
+
+    Args:
+        target: Path to the target repository.
+        branch: The Rhiza template branch to use (CLI argument).
+
+    Returns:
+        Tuple of (template, rhiza_repo, rhiza_branch, include_paths, excluded_paths).
+    """
     # Validate Rhiza configuration
-    # -----------------------
-    # The validate function checks if template.yml exists and is valid
-    # Returns True if valid, False otherwise
     valid = validate(target)
-
     if not valid:
         logger.error(f"Rhiza template is invalid in: {target}")
         logger.error("Please fix validation errors and try again")
         sys.exit(1)
 
-    # Load the template configuration from the validated file
-    # Validation ensures the file exists at .rhiza/template.yml
+    # Load the template configuration
     template_file = target / ".rhiza" / "template.yml"
     template = RhizaTemplate.from_yaml(template_file)
 
     # Extract template configuration settings
-    # These define where to clone from and what to materialize
     rhiza_repo = template.template_repository
-    # Use CLI arg if template doesn't specify a branch
     rhiza_branch = template.template_branch or branch
-    # Default to GitHub if not specified
-    rhiza_host = template.template_host or "github"
     include_paths = template.include
     excluded_paths = template.exclude
 
@@ -148,21 +101,32 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         logger.error("Add at least one path to the 'include' list in template.yml")
         raise RuntimeError("No include paths found in template.yml")
 
-    # Log the paths we'll be including for transparency
+    # Log the paths we'll be including
     logger.info("Include paths:")
     for p in include_paths:
         logger.info(f"  - {p}")
 
-    # Log excluded paths if any are defined
     if excluded_paths:
         logger.info("Exclude paths:")
         for p in excluded_paths:
             logger.info(f"  - {p}")
 
-    # -----------------------
-    # Construct git clone URL based on host
-    # -----------------------
-    # Support both GitHub and GitLab template repositories
+    return template, rhiza_repo, rhiza_branch, include_paths, excluded_paths
+
+
+def _construct_git_url(rhiza_repo: str, rhiza_host: str) -> str:
+    """Construct git clone URL based on host.
+
+    Args:
+        rhiza_repo: Repository name in 'owner/repo' format.
+        rhiza_host: Git hosting platform ('github' or 'gitlab').
+
+    Returns:
+        Git URL for cloning.
+
+    Raises:
+        ValueError: If rhiza_host is not supported.
+    """
     if rhiza_host == "gitlab":
         git_url = f"https://gitlab.com/{rhiza_repo}.git"
         logger.debug(f"Using GitLab repository: {git_url}")
@@ -173,144 +137,160 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         logger.error(f"Unsupported template-host: {rhiza_host}")
         logger.error("template-host must be 'github' or 'gitlab'")
         raise ValueError(f"Unsupported template-host: {rhiza_host}. Must be 'github' or 'gitlab'.")
+    return git_url
 
-    # -----------------------
-    # Sparse clone template repo
-    # -----------------------
-    # Create a temporary directory for the sparse clone
-    # This will be cleaned up in the finally block
-    tmp_dir = Path(tempfile.mkdtemp())
-    materialized_files: list[Path] = []
 
-    logger.info(f"Cloning {rhiza_repo}@{rhiza_branch} from {rhiza_host} into temporary directory")
-    logger.debug(f"Temporary directory: {tmp_dir}")
+def _clone_template_repository(
+    tmp_dir: Path,
+    git_url: str,
+    rhiza_branch: str,
+    include_paths: list[str],
+    git_executable: str,
+    git_env: dict[str, str],
+) -> None:
+    """Clone template repository with sparse checkout.
 
+    Args:
+        tmp_dir: Temporary directory for cloning.
+        git_url: Git repository URL.
+        rhiza_branch: Branch to clone.
+        include_paths: Paths to include in sparse checkout.
+        git_executable: Path to git executable.
+        git_env: Environment variables for git commands.
+    """
+    # Clone the repository using sparse checkout
     try:
-        # Clone the repository using sparse checkout for efficiency
-        # --depth 1: Only fetch the latest commit (shallow clone)
-        # --filter=blob:none: Don't download file contents initially
-        # --sparse: Enable sparse checkout mode
-        # This combination allows us to clone only the paths we need
-        try:
-            logger.debug("Executing git clone with sparse checkout")
-            subprocess.run(
-                [
-                    "git",
-                    "clone",
-                    "--depth",
-                    "1",
-                    "--filter=blob:none",
-                    "--sparse",
-                    "--branch",
-                    rhiza_branch,
-                    git_url,
-                    str(tmp_dir),
-                ],
-                check=True,
-                capture_output=True,
-                text=True,
-                env=git_env,
-            )
-            logger.debug("Git clone completed successfully")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Failed to clone repository: {e}")
-            if e.stderr:
-                logger.error(f"Git error: {e.stderr.strip()}")
-            logger.error(f"Check that the repository '{rhiza_repo}' exists and branch '{rhiza_branch}' is valid")
-            raise
-
-        # Initialize sparse checkout in cone mode
-        # Cone mode is more efficient and uses pattern matching
-        try:
-            logger.debug("Initializing sparse checkout")
-            subprocess.run(
-                ["git", "sparse-checkout", "init", "--cone"],
-                cwd=tmp_dir,
-                check=True,
-                capture_output=True,
-                text=True,
-                env=git_env,
-            )
-            logger.debug("Sparse checkout initialized")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Failed to initialize sparse checkout: {e}")
-            if e.stderr:
-                logger.error(f"Git error: {e.stderr.strip()}")
-            raise
-
-        # Set sparse checkout paths to only checkout the files/directories we need
-        # --skip-checks: Don't validate that patterns match existing files
-        try:
-            logger.debug(f"Setting sparse checkout paths: {include_paths}")
-            subprocess.run(
-                ["git", "sparse-checkout", "set", "--skip-checks", *include_paths],
-                cwd=tmp_dir,
-                check=True,
-                capture_output=True,
-                text=True,
-                env=git_env,
-            )
-            logger.debug("Sparse checkout paths configured")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"Failed to set sparse checkout paths: {e}")
-            if e.stderr:
-                logger.error(f"Git error: {e.stderr.strip()}")
-            raise
-
-        # -----------------------
-        # Expand include/exclude paths
-        # -----------------------
-        # Convert directory paths to individual file paths for precise control
-        logger.debug("Expanding included paths to individual files")
-        all_files = __expand_paths(tmp_dir, include_paths)
-        logger.info(f"Found {len(all_files)} file(s) in included paths")
-
-        # Create a set of excluded files for fast lookup
-        logger.debug("Expanding excluded paths to individual files")
-        excluded_files = {f.resolve() for f in __expand_paths(tmp_dir, excluded_paths)}
-        if excluded_files:
-            logger.info(f"Excluding {len(excluded_files)} file(s) based on exclude patterns")
-
-        # Filter out excluded files from the list of files to copy
-        files_to_copy = [f for f in all_files if f.resolve() not in excluded_files]
-        logger.info(f"Will materialize {len(files_to_copy)} file(s) to target repository")
-
-        # -----------------------
-        # Copy files into target repo
-        # -----------------------
-        # Copy each file from the temporary clone to the target repository
-        # Preserve file metadata (timestamps, permissions) with copy2
-        logger.info("Copying files to target repository...")
-        for src_file in files_to_copy:
-            # Calculate destination path maintaining relative structure
-            dst_file = target / src_file.relative_to(tmp_dir)
-            relative_path = dst_file.relative_to(target)
-
-            # Track this file for .rhiza.history
-            materialized_files.append(relative_path)
-
-            # Check if file already exists and handle based on force flag
-            if dst_file.exists() and not force:
-                logger.warning(f"{relative_path} already exists — use --force to overwrite")
-                continue
-
-            # Create parent directories if they don't exist
-            dst_file.parent.mkdir(parents=True, exist_ok=True)
-
-            # Copy file with metadata preservation
-            shutil.copy2(src_file, dst_file)
-            logger.success(f"[ADD] {relative_path}")
+        logger.debug("Executing git clone with sparse checkout")
+        subprocess.run(
+            [
+                git_executable,
+                "clone",
+                "--depth",
+                "1",
+                "--filter=blob:none",
+                "--sparse",
+                "--branch",
+                rhiza_branch,
+                git_url,
+                str(tmp_dir),
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+            env=git_env,
+        )
+        logger.debug("Git clone completed successfully")
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to clone repository: {e}")
+        if e.stderr:
+            logger.error(f"Git error: {e.stderr.strip()}")
+        logger.error(f"Check that the repository exists and branch '{rhiza_branch}' is valid")
+        raise
+
+    # Initialize sparse checkout in cone mode
+    try:
+        logger.debug("Initializing sparse checkout")
+        subprocess.run(
+            [git_executable, "sparse-checkout", "init", "--cone"],
+            cwd=tmp_dir,
+            check=True,
+            capture_output=True,
+            text=True,
+            env=git_env,
+        )
+        logger.debug("Sparse checkout initialized")
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to initialize sparse checkout: {e}")
+        if e.stderr:
+            logger.error(f"Git error: {e.stderr.strip()}")
+        raise
+
+    # Set sparse checkout paths
+    try:
+        logger.debug(f"Setting sparse checkout paths: {include_paths}")
+        subprocess.run(
+            [git_executable, "sparse-checkout", "set", "--skip-checks", *include_paths],
+            cwd=tmp_dir,
+            check=True,
+            capture_output=True,
+            text=True,
+            env=git_env,
+        )
+        logger.debug("Sparse checkout paths configured")
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to set sparse checkout paths: {e}")
+        if e.stderr:
+            logger.error(f"Git error: {e.stderr.strip()}")
+        raise
+
+
+def _copy_files_to_target(
+    tmp_dir: Path,
+    target: Path,
+    include_paths: list[str],
+    excluded_paths: list[str],
+    force: bool,
+) -> list[Path]:
+    """Copy files from temporary clone to target repository.
 
-    finally:
-        # Clean up the temporary directory
-        logger.debug(f"Cleaning up temporary directory: {tmp_dir}")
-        shutil.rmtree(tmp_dir)
+    Args:
+        tmp_dir: Temporary directory with cloned files.
+        target: Target repository path.
+        include_paths: Paths to include.
+        excluded_paths: Paths to exclude.
+        force: Whether to overwrite existing files.
 
-    # -----------------------
-    # Warn about workflow files
-    # -----------------------
-    # GitHub Actions workflow files require special permissions to modify
-    # Check if any of the materialized files are workflow files
+    Returns:
+        List of materialized file paths (relative to target).
+    """
+    # Expand paths to individual files
+    logger.debug("Expanding included paths to individual files")
+    all_files = __expand_paths(tmp_dir, include_paths)
+    logger.info(f"Found {len(all_files)} file(s) in included paths")
+
+    # Create set of excluded files
+    logger.debug("Expanding excluded paths to individual files")
+    excluded_files = {f.resolve() for f in __expand_paths(tmp_dir, excluded_paths)}
+    if excluded_files:
+        logger.info(f"Excluding {len(excluded_files)} file(s) based on exclude patterns")
+
+    # Filter out excluded files
+    files_to_copy = [f for f in all_files if f.resolve() not in excluded_files]
+    logger.info(f"Will materialize {len(files_to_copy)} file(s) to target repository")
+
+    # Copy files to target repository
+    logger.info("Copying files to target repository...")
+    materialized_files: list[Path] = []
+
+    for src_file in files_to_copy:
+        # Calculate destination path maintaining relative structure
+        dst_file = target / src_file.relative_to(tmp_dir)
+        relative_path = dst_file.relative_to(target)
+
+        # Track this file for history
+        materialized_files.append(relative_path)
+
+        # Check if file exists and handle based on force flag
+        if dst_file.exists() and not force:
+            logger.warning(f"{relative_path} already exists — use --force to overwrite")
+            continue
+
+        # Create parent directories if needed
+        dst_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Copy file with metadata preservation
+        shutil.copy2(src_file, dst_file)
+        logger.success(f"[ADD] {relative_path}")
+
+    return materialized_files
+
+
+def _warn_about_workflow_files(materialized_files: list[Path]) -> None:
+    """Warn if workflow files were materialized.
+
+    Args:
+        materialized_files: List of materialized file paths.
+    """
     workflow_files = [p for p in materialized_files if p.parts[:2] == (".github", "workflows")]
 
     if workflow_files:
@@ -320,16 +300,19 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         )
         logger.info(f"Workflow files affected: {len(workflow_files)}")
 
-    # -----------------------
-    # Clean up orphaned files
-    # -----------------------
-    # Read the old history file to find files that are no longer
-    # part of the current materialization and should be deleted
-    # Check both new and old locations for backward compatibility
+
+def _clean_orphaned_files(target: Path, materialized_files: list[Path]) -> None:
+    """Clean up files that are no longer maintained by template.
+
+    Args:
+        target: Target repository path.
+        materialized_files: List of currently materialized files.
+    """
+    # Read old history file
     new_history_file = target / ".rhiza" / "history"
     old_history_file = target / ".rhiza.history"
 
-    # Prefer new location, but check old location for migration
+    # Prefer new location, check old for migration
     if new_history_file.exists():
         history_file = new_history_file
         logger.debug(f"Reading existing history file from new location: {history_file.relative_to(target)}")
@@ -337,25 +320,20 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         history_file = old_history_file
         logger.debug(f"Reading existing history file from old location: {history_file.relative_to(target)}")
     else:
-        history_file = new_history_file  # Default to new location for creation
-        logger.debug("No existing history file found, will create new one")
+        logger.debug("No existing history file found")
+        return
 
     previously_tracked_files: set[Path] = set()
+    with history_file.open("r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith("#"):
+                previously_tracked_files.add(Path(line))
 
-    if history_file.exists():
-        with history_file.open("r", encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                # Skip comments and empty lines
-                if line and not line.startswith("#"):
-                    previously_tracked_files.add(Path(line))
+    logger.debug(f"Found {len(previously_tracked_files)} file(s) in previous history")
 
-        logger.debug(f"Found {len(previously_tracked_files)} file(s) in previous history")
-
-    # Convert materialized_files list to a set for comparison
+    # Find orphaned files
     currently_materialized_files = set(materialized_files)
-
-    # Find orphaned files (in old history but not in new materialization)
     orphaned_files = previously_tracked_files - currently_materialized_files
 
     if orphaned_files:
@@ -373,15 +351,18 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
     else:
         logger.debug("No orphaned files to clean up")
 
-    # -----------------------
-    # Write history file
-    # -----------------------
-    # This file tracks which files were materialized by Rhiza
-    # Useful for understanding which files came from the template
-    # Always write to new location (.rhiza/history)
-    history_file = target / ".rhiza" / "history"
 
-    # Ensure .rhiza directory exists
+def _write_history_file(target: Path, materialized_files: list[Path], rhiza_repo: str, rhiza_branch: str) -> None:
+    """Write history file tracking materialized files.
+
+    Args:
+        target: Target repository path.
+        materialized_files: List of materialized files.
+        rhiza_repo: Template repository name.
+        rhiza_branch: Template branch name.
+    """
+    # Always write to new location
+    history_file = target / ".rhiza" / "history"
     history_file.parent.mkdir(parents=True, exist_ok=True)
 
     logger.debug(f"Writing history file: {history_file.relative_to(target)}")
@@ -392,7 +373,6 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         f.write(f"# Template branch: {rhiza_branch}\n")
         f.write("#\n")
         f.write("# Files under template control:\n")
-        # Sort files for consistent ordering
         for file_path in sorted(materialized_files):
             f.write(f"{file_path}\n")
 
@@ -407,8 +387,89 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         except Exception as e:
             logger.warning(f"Could not remove old history file: {e}")
 
-    logger.success("Rhiza templates materialized successfully")
 
+def __expand_paths(base_dir: Path, paths: list[str]) -> list[Path]:
+    """Expand files/directories relative to base_dir into a flat list of files.
+
+    Given a list of paths relative to ``base_dir``, return a flat list of all
+    individual files.
+
+    Args:
+        base_dir: The base directory to resolve paths against.
+        paths: List of relative path strings (files or directories).
+
+    Returns:
+        A flat list of Path objects representing all individual files found.
+    """
+    all_files = []
+    for p in paths:
+        full_path = base_dir / p
+        # Check if the path is a regular file
+        if full_path.is_file():
+            all_files.append(full_path)
+        # If it's a directory, recursively find all files within it
+        elif full_path.is_dir():
+            all_files.extend([f for f in full_path.rglob("*") if f.is_file()])
+        else:
+            # Path does not exist in the cloned repository - skip it silently
+            # This can happen if the template repo doesn't have certain paths
+            logger.debug(f"Path not found in template repository: {p}")
+            continue
+    return all_files
+
+
+def materialize(target: Path, branch: str, target_branch: str | None, force: bool) -> None:
+    """Materialize Rhiza templates into the target repository.
+
+    This performs a sparse checkout of the template repository and copies the
+    selected files into the target repository, recording all files under
+    template control in `.rhiza/history`.
+
+    Args:
+        target (Path): Path to the target repository.
+        branch (str): The Rhiza template branch to use.
+        target_branch (str | None): Optional branch name to create/checkout in
+            the target repository.
+        force (bool): Whether to overwrite existing files.
+    """
+    target = target.resolve()
+    logger.info(f"Target repository: {target}")
+    logger.info(f"Rhiza branch: {branch}")
+
+    # Setup git environment
+    git_executable = get_git_executable()
+    logger.debug(f"Using git executable: {git_executable}")
+    git_env = os.environ.copy()
+    git_env["GIT_TERMINAL_PROMPT"] = "0"
+
+    # Handle target branch if specified
+    _handle_target_branch(target, target_branch, git_executable, git_env)
+
+    # Validate and load template configuration
+    template, rhiza_repo, rhiza_branch, include_paths, excluded_paths = _validate_and_load_template(target, branch)
+    rhiza_host = template.template_host or "github"
+
+    # Construct git URL
+    git_url = _construct_git_url(rhiza_repo, rhiza_host)
+
+    # Clone template repository
+    tmp_dir = Path(tempfile.mkdtemp())
+    logger.info(f"Cloning {rhiza_repo}@{rhiza_branch} from {rhiza_host} into temporary directory")
+    logger.debug(f"Temporary directory: {tmp_dir}")
+
+    try:
+        _clone_template_repository(tmp_dir, git_url, rhiza_branch, include_paths, git_executable, git_env)
+        materialized_files = _copy_files_to_target(tmp_dir, target, include_paths, excluded_paths, force)
+    finally:
+        logger.debug(f"Cleaning up temporary directory: {tmp_dir}")
+        shutil.rmtree(tmp_dir)
+
+    # Post-processing
+    _warn_about_workflow_files(materialized_files)
+    _clean_orphaned_files(target, materialized_files)
+    _write_history_file(target, materialized_files, rhiza_repo, rhiza_branch)
+
+    logger.success("Rhiza templates materialized successfully")
     logger.info(
         "Next steps:\n"
         "  1. Review changes:\n"