rhiza 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

rhiza/__main__.py

@@ -11,7 +11,7 @@ import typer
 from rhiza.cli import app
 
 
-def load_plugins(app: typer.Typer):
+def load_plugins(app: typer.Typer) -> None:
     """Load plugins from entry points."""
     # 'rhiza.plugins' matches the group we defined in rhiza-tools
     plugin_entries = entry_points(group="rhiza.plugins")

rhiza/bundle_resolver.py

@@ -0,0 +1,78 @@
+"""Bundle resolution logic for template configuration.
+
+This module provides functions to load and resolve bundle configurations
+from the template repository's bundles.yml file.
+"""
+
+from pathlib import Path
+
+from rhiza.models import RhizaBundles, RhizaTemplate
+
+
+def load_bundles_from_clone(tmp_dir: Path) -> RhizaBundles | None:
+    """Load .rhiza/bundles.yml from cloned template repo.
+
+    Args:
+        tmp_dir: Path to the cloned template repository.
+
+    Returns:
+        RhizaBundles if bundles.yml exists, None otherwise.
+
+    Raises:
+        yaml.YAMLError: If bundles.yml is malformed.
+        ValueError: If bundles.yml is invalid.
+    """
+    bundles_file = tmp_dir / ".rhiza" / "bundles.yml"
+    if not bundles_file.exists():
+        return None
+    return RhizaBundles.from_yaml(bundles_file)
+
+
+def resolve_include_paths(
+    template: RhizaTemplate,
+    bundles_config: RhizaBundles | None,
+) -> list[str]:
+    """Resolve template configuration to file paths.
+
+    Supports:
+    - Template-based mode (templates field)
+    - Path-based mode (include field)
+    - Hybrid mode (both templates and include)
+
+    Args:
+        template: The template configuration.
+        bundles_config: The loaded bundles configuration, or None if not available.
+
+    Returns:
+        List of file paths to materialize.
+
+    Raises:
+        ValueError: If configuration is invalid or bundles.yml is missing.
+    """
+    paths = []
+
+    # Resolve templates to paths if specified
+    if template.templates:
+        if not bundles_config:
+            msg = "Template uses templates but bundles.yml not found in template repository"
+            raise ValueError(msg)
+        paths.extend(bundles_config.resolve_to_paths(template.templates))
+
+    # Add include paths if specified
+    if template.include:
+        paths.extend(template.include)
+
+    # At least one must be specified
+    if not paths:
+        msg = "Template configuration must specify either 'templates' or 'include'"
+        raise ValueError(msg)
+
+    # Deduplicate while preserving order
+    seen = set()
+    deduplicated = []
+    for path in paths:
+        if path not in seen:
+            deduplicated.append(path)
+            seen.add(path)
+
+    return deduplicated

rhiza/cli.py

@@ -23,14 +23,14 @@ app = typer.Typer(
         """
         Rhiza - Manage reusable configuration templates for Python projects
 
-        \x1b]8;;https://jebel-quant.github.io/rhiza-cli/\x1b\\https://jebel-quant.github.io/rhiza-cli/\x1b]8;;\x1b\\
+        https://jebel-quant.github.io/rhiza-cli/
         """
     ),
     add_completion=True,
 )
 
 
-def version_callback(value: bool):
+def version_callback(value: bool) -> None:
     """Print version information and exit.
 
     Args:
@@ -54,7 +54,7 @@ def main(
         callback=version_callback,
         is_eager=True,
     ),
-):
+) -> None:
     """Rhiza CLI main callback.
 
     This callback is executed before any command. It handles global options
@@ -107,7 +107,7 @@ def init(
         "--template-branch",
         help="Custom template branch. Defaults to 'main'.",
     ),
-):
+) -> None:
     r"""Initialize or validate .rhiza/template.yml.
 
     Creates a default `.rhiza/template.yml` configuration file if one
@@ -157,7 +157,7 @@ def materialize(
         help="Create and checkout a new branch in the target repository for changes",
     ),
     force: bool = typer.Option(False, "--force", "-y", help="Overwrite existing files"),
-):
+) -> None:
     r"""Inject Rhiza configuration templates into a target repository.
 
     Materializes configuration files from the template repository specified
@@ -190,7 +190,7 @@ def validate(
             help="Target git repository (defaults to current directory)",
         ),
     ] = Path("."),
-):
+) -> None:
     r"""Validate Rhiza template configuration.
 
     Validates the .rhiza/template.yml file to ensure it is syntactically
@@ -227,7 +227,7 @@ def migrate(
             help="Target git repository (defaults to current directory)",
         ),
     ] = Path("."),
-):
+) -> None:
     r"""Migrate project to the new .rhiza folder structure.
 
     This command helps transition projects to use the new `.rhiza/` folder
@@ -253,7 +253,7 @@ def migrate(
 
 
 @app.command()
-def welcome():
+def welcome() -> None:
     r"""Display a friendly welcome message and explain what Rhiza is.
 
     Shows a welcome message, explains Rhiza's purpose, key features,
@@ -282,7 +282,7 @@ def uninstall(
         "-y",
         help="Skip confirmation prompt and proceed with deletion",
     ),
-):
+) -> None:
     r"""Remove all Rhiza-managed files from the repository.
 
     Reads the `.rhiza.history` file and removes all files that were
@@ -327,7 +327,7 @@ def summarise(
             help="Output file path (defaults to stdout)",
         ),
     ] = None,
-):
+) -> None:
     r"""Generate a summary of staged changes for PR descriptions.
 
     Analyzes staged git changes and generates a structured PR description

rhiza/commands/__init__.py

@@ -50,6 +50,8 @@ For more detailed usage examples and workflows, see the USAGE.md guide
 or try rhiza <command> --help
 """
 
-from .init import init  # noqa: F401
-from .materialize import materialize  # noqa: F401
-from .validate import validate  # noqa: F401
+from .init import init
+from .materialize import materialize
+from .validate import validate
+
+__all__ = ["init", "materialize", "validate"]

rhiza/commands/init.py

@@ -81,11 +81,27 @@ def _prompt_git_host() -> str:
         git_host = "github"
         logger.debug("Non-interactive mode detected, defaulting to github")
 
-    return git_host
+    return str(git_host)
+
+
+def _get_default_templates_for_host(git_host: str) -> list[str]:
+    """Get default templates based on git hosting platform.
+
+    Args:
+        git_host: Git hosting platform.
+
+    Returns:
+        List of template names.
+    """
+    common = ["core", "tests", "docs"]
+    if git_host == "gitlab":
+        return [*common, "gitlab"]
+    else:
+        return [*common, "github"]
 
 
 def _get_include_paths_for_host(git_host: str) -> list[str]:
-    """Get include paths based on git hosting platform.
+    """Get include paths based on git hosting platform (legacy, path-based).
 
     Args:
         git_host: Git hosting platform.
@@ -129,6 +145,7 @@ def _create_template_file(
     git_host: str,
     template_repository: str | None = None,
     template_branch: str | None = None,
+    use_templates: bool = True,
 ) -> None:
     """Create default template.yml file.
 
@@ -137,6 +154,7 @@ def _create_template_file(
         git_host: Git hosting platform.
         template_repository: Custom template repository (format: owner/repo).
         template_branch: Custom template branch.
+        use_templates: Use template-based configuration if True, path-based if False.
     """
     rhiza_dir = target / ".rhiza"
     template_file = rhiza_dir / "template.yml"
@@ -147,8 +165,6 @@ def _create_template_file(
     logger.info("Creating default .rhiza/template.yml")
     logger.debug("Using default template configuration")
 
-    include_paths = _get_include_paths_for_host(git_host)
-
     # Use custom template repository/branch if provided, otherwise use defaults
     repo = template_repository or "jebel-quant/rhiza"
     branch = template_branch or "main"
@@ -159,11 +175,22 @@ def _create_template_file(
     if template_branch:
         logger.info(f"Using custom template branch: {branch}")
 
-    default_template = RhizaTemplate(
-        template_repository=repo,
-        template_branch=branch,
-        include=include_paths,
-    )
+    if use_templates:
+        templates = _get_default_templates_for_host(git_host)
+        logger.info(f"Using template-based configuration with templates: {', '.join(templates)}")
+        default_template = RhizaTemplate(
+            template_repository=repo,
+            template_branch=branch,
+            templates=templates,
+        )
+    else:
+        include_paths = _get_include_paths_for_host(git_host)
+        logger.info("Using path-based configuration")
+        default_template = RhizaTemplate(
+            template_repository=repo,
+            template_branch=branch,
+            include=include_paths,
+        )
 
     logger.debug(f"Writing default template to: {template_file}")
     default_template.to_yaml(template_file)
@@ -263,7 +290,7 @@ def init(
     git_host: str | None = None,
     template_repository: str | None = None,
     template_branch: str | None = None,
-):
+) -> bool:
     """Initialize or validate .rhiza/template.yml in the target repository.
 
     Creates a default .rhiza/template.yml file if it doesn't exist,

rhiza/commands/materialize.py

@@ -15,11 +15,28 @@ from pathlib import Path
 
 from loguru import logger
 
+from rhiza.bundle_resolver import load_bundles_from_clone, resolve_include_paths
 from rhiza.commands.validate import validate
 from rhiza.models import RhizaTemplate
 from rhiza.subprocess_utils import get_git_executable
 
 
+def _log_git_stderr_errors(stderr: str | None) -> None:
+    """Extract and log only relevant error messages from git stderr.
+
+    Args:
+        stderr: Git command stderr output.
+    """
+    if stderr:
+        # Extract relevant error message from git stderr
+        stderr_lines = stderr.strip().split("\n")
+        # Show only the most relevant error lines, skip verbose git output
+        for line in stderr_lines:
+            line = line.strip()
+            if line and (line.startswith("fatal:") or line.startswith("error:")):
+                logger.error(line)
+
+
 def _handle_target_branch(
     target: Path, target_branch: str | None, git_executable: str, git_env: dict[str, str]
 ) -> None:
@@ -52,6 +69,8 @@ def _handle_target_branch(
                 [git_executable, "checkout", target_branch],
                 cwd=target,
                 check=True,
+                capture_output=True,
+                text=True,
                 env=git_env,
             )
         else:
@@ -61,10 +80,14 @@ def _handle_target_branch(
                 [git_executable, "checkout", "-b", target_branch],
                 cwd=target,
                 check=True,
+                capture_output=True,
+                text=True,
                 env=git_env,
             )
     except subprocess.CalledProcessError as e:
-        logger.error(f"Failed to create/checkout branch '{target_branch}': {e}")
+        logger.error(f"Failed to create/checkout branch '{target_branch}'")
+        _log_git_stderr_errors(e.stderr)
+        logger.error("Please ensure you have no uncommitted changes or conflicts")
         sys.exit(1)
 
 
@@ -91,20 +114,32 @@ def _validate_and_load_template(target: Path, branch: str) -> tuple[RhizaTemplat
 
     # Extract template configuration settings
     rhiza_repo = template.template_repository
+    if not rhiza_repo:
+        logger.error("template-repository is not configured in template.yml")
+        raise RuntimeError("template-repository is required")  # noqa: TRY003
     rhiza_branch = template.template_branch or branch
-    include_paths = template.include
     excluded_paths = template.exclude
 
-    # Validate that we have paths to include
-    if not include_paths:
-        logger.error("No include paths found in template.yml")
-        logger.error("Add at least one path to the 'include' list in template.yml")
-        raise RuntimeError("No include paths found in template.yml")  # noqa: TRY003
+    # Note: We'll resolve templates to paths after cloning the template repo,
+    # since we need access to bundles.yml from the template
+    include_paths = template.include
 
-    # Log the paths we'll be including
-    logger.info("Include paths:")
-    for p in include_paths:
-        logger.info(f"  - {p}")
+    # Validate that we have either templates or include paths
+    if not template.templates and not include_paths:
+        logger.error("No templates or include paths found in template.yml")
+        logger.error("Add either 'templates' or 'include' list in template.yml")
+        raise RuntimeError("No templates or include paths found in template.yml")  # noqa: TRY003
+
+    # Log what we'll be using
+    if template.templates:
+        logger.info("Templates:")
+        for t in template.templates:
+            logger.info(f"  - {t}")
+
+    if include_paths:
+        logger.info("Include paths:")
+        for p in include_paths:
+            logger.info(f"  - {p}")
 
     if excluded_paths:
         logger.info("Exclude paths:")
@@ -140,6 +175,37 @@ def _construct_git_url(rhiza_repo: str, rhiza_host: str) -> str:
     return git_url
 
 
+def _update_sparse_checkout(
+    tmp_dir: Path,
+    include_paths: list[str],
+    git_executable: str,
+    git_env: dict[str, str],
+) -> None:
+    """Update sparse checkout paths in an already-cloned repository.
+
+    Args:
+        tmp_dir: Temporary directory with cloned repository.
+        include_paths: Paths to include in sparse checkout.
+        git_executable: Path to git executable.
+        git_env: Environment variables for git commands.
+    """
+    try:
+        logger.debug(f"Updating sparse checkout paths: {include_paths}")
+        subprocess.run(  # nosec B603
+            [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 updated")
+    except subprocess.CalledProcessError as e:
+        logger.error("Failed to update sparse checkout paths")
+        _log_git_stderr_errors(e.stderr)
+        sys.exit(1)
+
+
 def _clone_template_repository(
     tmp_dir: Path,
     git_url: str,
@@ -154,7 +220,7 @@ def _clone_template_repository(
         tmp_dir: Temporary directory for cloning.
         git_url: Git repository URL.
         rhiza_branch: Branch to clone.
-        include_paths: Paths to include in sparse checkout.
+        include_paths: Initial paths to include in sparse checkout.
         git_executable: Path to git executable.
         git_env: Environment variables for git commands.
     """
@@ -181,11 +247,13 @@ def _clone_template_repository(
         )
         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
+        logger.error(f"Failed to clone repository from {git_url}")
+        _log_git_stderr_errors(e.stderr)
+        logger.error("Please check that:")
+        logger.error("  - The repository exists and is accessible")
+        logger.error(f"  - Branch '{rhiza_branch}' exists in the repository")
+        logger.error("  - You have network access to the git hosting service")
+        sys.exit(1)
 
     # Initialize sparse checkout in cone mode
     try:
@@ -200,10 +268,9 @@ def _clone_template_repository(
         )
         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
+        logger.error("Failed to initialize sparse checkout")
+        _log_git_stderr_errors(e.stderr)
+        sys.exit(1)
 
     # Set sparse checkout paths
     try:
@@ -218,10 +285,9 @@ def _clone_template_repository(
         )
         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
+        logger.error("Failed to configure sparse checkout paths")
+        _log_git_stderr_errors(e.stderr)
+        sys.exit(1)
 
 
 def _copy_files_to_target(
@@ -479,7 +545,25 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
     logger.debug(f"Temporary directory: {tmp_dir}")
 
     try:
-        _clone_template_repository(tmp_dir, git_url, rhiza_branch, include_paths, git_executable, git_env)
+        # Clone with initial minimal checkout to load bundles.yml if needed
+        initial_paths = [".rhiza"] if template.templates else include_paths
+        _clone_template_repository(tmp_dir, git_url, rhiza_branch, initial_paths, git_executable, git_env)
+
+        # Load bundles.yml and resolve templates to paths if using template mode
+        if template.templates:
+            logger.info("Resolving templates to file paths...")
+            try:
+                bundles_config = load_bundles_from_clone(tmp_dir)
+                resolved_paths = resolve_include_paths(template, bundles_config)
+                logger.info(f"Resolved {len(template.templates)} template(s) to {len(resolved_paths)} path(s)")
+                logger.debug(f"Resolved paths: {resolved_paths}")
+                # Update sparse checkout with resolved paths
+                _update_sparse_checkout(tmp_dir, resolved_paths, git_executable, git_env)
+                include_paths = resolved_paths
+            except ValueError as e:
+                logger.error(f"Failed to resolve templates: {e}")
+                sys.exit(1)
+
         materialized_files = _copy_files_to_target(tmp_dir, target, include_paths, excluded_paths, force)
     finally:
         logger.debug(f"Cleaning up temporary directory: {tmp_dir}")

rhiza/commands/summarise.py

@@ -46,7 +46,7 @@ def get_staged_changes(repo_path: Path) -> dict[str, list[str]]:
     Returns:
         Dictionary with keys 'added', 'modified', 'deleted' containing file lists
     """
-    changes = {
+    changes: dict[str, list[str]] = {
         "added": [],
         "modified": [],
         "deleted": [],

rhiza/commands/validate.py

@@ -5,8 +5,9 @@ This module provides functionality to validate template.yml files in the
 """
 
 from pathlib import Path
+from typing import Any
 
-import yaml
+import yaml  # type: ignore[import-untyped]
 from loguru import logger
 
 
@@ -98,7 +99,7 @@ def _check_template_file_exists(target: Path) -> tuple[bool, Path]:
     return True, template_file
 
 
-def _parse_yaml_file(template_file: Path) -> tuple[bool, dict | None]:
+def _parse_yaml_file(template_file: Path) -> tuple[bool, dict[str, Any] | None]:
     """Parse YAML file and return configuration.
 
     Args:
@@ -125,7 +126,79 @@ def _parse_yaml_file(template_file: Path) -> tuple[bool, dict | None]:
     return True, config
 
 
-def _validate_required_fields(config: dict) -> bool:
+def _validate_configuration_mode(config: dict[str, Any]) -> bool:
+    """Validate that at least one of templates or include is specified.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        True if configuration mode is valid, False otherwise.
+    """
+    logger.debug("Validating configuration mode")
+    has_templates = "templates" in config and config["templates"]
+    has_include = "include" in config and config["include"]
+
+    # Error if old "bundles" field is used
+    if "bundles" in config:
+        logger.error("Field 'bundles' has been renamed to 'templates'")
+        logger.error("Update your .rhiza/template.yml:")
+        logger.error("  bundles: [...]  →  templates: [...]")
+        return False
+
+    # Require at least one of templates or include
+    if not has_templates and not has_include:
+        logger.error("Must specify at least one of 'templates' or 'include' in template.yml")
+        logger.error("Options:")
+        logger.error("  • Template-based: templates: [core, tests, github]")
+        logger.error("  • Path-based: include: [.rhiza, .github, ...]")
+        logger.error("  • Hybrid: specify both templates and include")
+        return False
+
+    # Log what mode is being used
+    if has_templates and has_include:
+        logger.success("Using hybrid mode (templates + include)")
+    elif has_templates:
+        logger.success("Using template-based mode")
+    else:
+        logger.success("Using path-based mode")
+
+    return True
+
+
+def _validate_templates(config: dict[str, Any]) -> bool:
+    """Validate templates field if present.
+
+    Args:
+        config: Configuration dictionary.
+
+    Returns:
+        True if templates field is valid, False otherwise.
+    """
+    logger.debug("Validating templates field")
+    if "templates" not in config:
+        return True
+
+    templates = config["templates"]
+    if not isinstance(templates, list):
+        logger.error(f"templates must be a list, got {type(templates).__name__}")
+        logger.error("Example: templates: [core, tests, github]")
+        return False
+    elif len(templates) == 0:
+        logger.error("templates list cannot be empty")
+        logger.error("Add at least one template to materialize")
+        return False
+    else:
+        logger.success(f"templates list has {len(templates)} template(s)")
+        for template in templates:
+            if not isinstance(template, str):
+                logger.warning(f"template name should be a string, got {type(template).__name__}: {template}")
+            else:
+                logger.info(f"  - {template}")
+        return True
+
+
+def _validate_required_fields(config: dict[str, Any]) -> bool:
     """Validate required fields exist and have correct types.
 
     Args:
@@ -135,9 +208,10 @@ def _validate_required_fields(config: dict) -> bool:
         True if all validations pass, False otherwise.
     """
     logger.debug("Validating required fields")
+    # template-repository is required
+    # include or bundles is required (validated separately)
     required_fields = {
         "template-repository": str,
-        "include": list,
     }
 
     validation_passed = True
@@ -159,7 +233,7 @@ def _validate_required_fields(config: dict) -> bool:
     return validation_passed
 
 
-def _validate_repository_format(config: dict) -> bool:
+def _validate_repository_format(config: dict[str, Any]) -> bool:
     """Validate template-repository format.
 
     Args:
@@ -186,7 +260,7 @@ def _validate_repository_format(config: dict) -> bool:
         return True
 
 
-def _validate_include_paths(config: dict) -> bool:
+def _validate_include_paths(config: dict[str, Any]) -> bool:
     """Validate include paths.
 
     Args:
@@ -218,7 +292,7 @@ def _validate_include_paths(config: dict) -> bool:
         return True
 
 
-def _validate_optional_fields(config: dict) -> None:
+def _validate_optional_fields(config: dict[str, Any]) -> None:
     """Validate optional fields if present.
 
     Args:
@@ -304,6 +378,10 @@ def validate(target: Path) -> bool:
     if not success or config is None:
         return False
 
+    # Validate configuration mode (templates OR include)
+    if not _validate_configuration_mode(config):
+        return False
+
     # Validate required fields
     validation_passed = _validate_required_fields(config)
 
@@ -311,8 +389,15 @@ def validate(target: Path) -> bool:
     if not _validate_repository_format(config):
         validation_passed = False
 
-    if not _validate_include_paths(config):
-        validation_passed = False
+    # Validate templates if present
+    if config.get("templates"):
+        if not _validate_templates(config):
+            validation_passed = False
+
+    # Validate include if present
+    if config.get("include"):
+        if not _validate_include_paths(config):
+            validation_passed = False
 
     # Validate optional fields
     _validate_optional_fields(config)

rhiza/commands/welcome.py

@@ -10,7 +10,7 @@ and explains what Rhiza is and how it can help manage configuration templates.
 from rhiza import __version__
 
 
-def welcome():
+def welcome() -> None:
     """Display a welcome message and explain what Rhiza is.
 
     Shows a friendly greeting, explains Rhiza's purpose, and provides

rhiza/models.py

@@ -7,12 +7,19 @@ YAML parsing.
 
 from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Any
 
-import yaml
+import yaml  # type: ignore[import-untyped]
+
+__all__ = [
+    "BundleDefinition",
+    "RhizaBundles",
+    "RhizaTemplate",
+]
 
 
 def _normalize_to_list(value: str | list[str] | None) -> list[str]:
-    """Convert a value to a list of strings.
+    r"""Convert a value to a list of strings.
 
     Handles the case where YAML multi-line strings (using |) are parsed as
     a single string instead of a list. Splits the string by newlines and
@@ -23,6 +30,20 @@ def _normalize_to_list(value: str | list[str] | None) -> list[str]:
 
     Returns:
         A list of strings. Empty list if value is None or empty.
+
+    Examples:
+        >>> _normalize_to_list(None)
+        []
+        >>> _normalize_to_list([])
+        []
+        >>> _normalize_to_list(['a', 'b', 'c'])
+        ['a', 'b', 'c']
+        >>> _normalize_to_list('single line')
+        ['single line']
+        >>> _normalize_to_list('line1\\n' + 'line2\\n' + 'line3')
+        ['line1', 'line2', 'line3']
+        >>> _normalize_to_list('  item1  \\n' + '  item2  ')
+        ['item1', 'item2']
     """
     if value is None:
         return []
@@ -30,10 +51,173 @@ def _normalize_to_list(value: str | list[str] | None) -> list[str]:
         return value
     if isinstance(value, str):
         # Split by newlines and filter out empty strings
-        return [item.strip() for item in value.strip().split("\n") if item.strip()]
+        # Handle both actual newlines (\n) and literal backslash-n (\\n)
+        if "\\n" in value and "\n" not in value:
+            # Contains literal \n but not actual newlines
+            items = value.split("\\n")
+        else:
+            # Contains actual newlines or neither
+            items = value.split("\n")
+        return [item.strip() for item in items if item.strip()]
     return []
 
 
+@dataclass
+class BundleDefinition:
+    """Represents a single bundle from bundles.yml.
+
+    Attributes:
+        name: The bundle identifier (e.g., "core", "tests", "github").
+        description: Human-readable description of the bundle.
+        files: List of file paths included in this bundle.
+        workflows: List of workflow file paths included in this bundle.
+        depends_on: List of bundle names that this bundle depends on.
+    """
+
+    name: str
+    description: str
+    files: list[str] = field(default_factory=list)
+    workflows: list[str] = field(default_factory=list)
+    depends_on: list[str] = field(default_factory=list)
+
+    def all_paths(self) -> list[str]:
+        """Return combined files and workflows."""
+        return self.files + self.workflows
+
+
+@dataclass
+class RhizaBundles:
+    """Represents the structure of bundles.yml.
+
+    Attributes:
+        version: Version string of the bundles configuration format.
+        bundles: Dictionary mapping bundle names to their definitions.
+    """
+
+    version: str
+    bundles: dict[str, BundleDefinition] = field(default_factory=dict)
+
+    @classmethod
+    def from_yaml(cls, file_path: Path) -> "RhizaBundles":
+        """Load RhizaBundles from a YAML file.
+
+        Args:
+            file_path: Path to the bundles.yml file.
+
+        Returns:
+            The loaded bundles configuration.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
+            yaml.YAMLError: If the YAML is malformed.
+            ValueError: If the file is invalid or missing required fields.
+            TypeError: If bundle data has invalid types.
+        """
+        with open(file_path) as f:
+            config = yaml.safe_load(f)
+
+        if not config:
+            raise ValueError("Bundles file is empty")  # noqa: TRY003
+
+        version = config.get("version")
+        if not version:
+            raise ValueError("Bundles file missing required field: version")  # noqa: TRY003
+
+        bundles_config = config.get("bundles", {})
+        if not isinstance(bundles_config, dict):
+            msg = "Bundles must be a dictionary"
+            raise TypeError(msg)
+
+        bundles: dict[str, BundleDefinition] = {}
+        for bundle_name, bundle_data in bundles_config.items():
+            if not isinstance(bundle_data, dict):
+                msg = f"Bundle '{bundle_name}' must be a dictionary"
+                raise TypeError(msg)
+
+            files = _normalize_to_list(bundle_data.get("files"))
+            workflows = _normalize_to_list(bundle_data.get("workflows"))
+            depends_on = _normalize_to_list(bundle_data.get("depends-on"))
+
+            bundles[bundle_name] = BundleDefinition(
+                name=bundle_name,
+                description=bundle_data.get("description", ""),
+                files=files,
+                workflows=workflows,
+                depends_on=depends_on,
+            )
+
+        return cls(version=version, bundles=bundles)
+
+    def resolve_dependencies(self, bundle_names: list[str]) -> list[str]:
+        """Resolve bundle dependencies using topological sort.
+
+        Args:
+            bundle_names: List of bundle names to resolve.
+
+        Returns:
+            Ordered list of bundle names with dependencies first, no duplicates.
+
+        Raises:
+            ValueError: If a bundle doesn't exist or circular dependency detected.
+        """
+        # Validate all bundles exist
+        for name in bundle_names:
+            if name not in self.bundles:
+                raise ValueError(f"Bundle '{name}' not found in bundles.yml")  # noqa: TRY003
+
+        resolved: list[str] = []
+        visiting: set[str] = set()
+        visited: set[str] = set()
+
+        def visit(bundle_name: str) -> None:
+            if bundle_name in visited:
+                return
+            if bundle_name in visiting:
+                raise ValueError(f"Circular dependency detected involving '{bundle_name}'")  # noqa: TRY003
+
+            visiting.add(bundle_name)
+            bundle = self.bundles[bundle_name]
+
+            for dep in bundle.depends_on:
+                if dep not in self.bundles:
+                    raise ValueError(f"Bundle '{bundle_name}' depends on unknown bundle '{dep}'")  # noqa: TRY003
+                visit(dep)
+
+            visiting.remove(bundle_name)
+            visited.add(bundle_name)
+            resolved.append(bundle_name)
+
+        for name in bundle_names:
+            visit(name)
+
+        return resolved
+
+    def resolve_to_paths(self, bundle_names: list[str]) -> list[str]:
+        """Convert bundle names to deduplicated file paths.
+
+        Args:
+            bundle_names: List of bundle names to resolve.
+
+        Returns:
+            Deduplicated list of file paths from all bundles and their dependencies.
+
+        Raises:
+            ValueError: If a bundle doesn't exist or circular dependency detected.
+        """
+        resolved_bundles = self.resolve_dependencies(bundle_names)
+        paths: list[str] = []
+        seen: set[str] = set()
+
+        for bundle_name in resolved_bundles:
+            bundle = self.bundles[bundle_name]
+            for path in bundle.all_paths():
+                if path not in seen:
+                    paths.append(path)
+                    seen.add(path)
+
+        return paths
+
+
 @dataclass
 class RhizaTemplate:
     """Represents the structure of .rhiza/template.yml.
@@ -45,8 +229,10 @@ class RhizaTemplate:
             Can be None if not specified in the template file (defaults to "main" when creating).
         template_host: The git hosting platform ("github" or "gitlab").
             Defaults to "github" if not specified in the template file.
-        include: List of paths to include from the template repository.
+        include: List of paths to include from the template repository (path-based mode).
         exclude: List of paths to exclude from the template repository (default: empty list).
+        templates: List of template names to include (template-based mode).
+            Can be used together with include to merge paths.
     """
 
     template_repository: str | None = None
@@ -54,6 +240,7 @@ class RhizaTemplate:
     template_host: str = "github"
     include: list[str] = field(default_factory=list)
     exclude: list[str] = field(default_factory=list)
+    templates: list[str] = field(default_factory=list)
 
     @classmethod
     def from_yaml(cls, file_path: Path) -> "RhizaTemplate":
@@ -82,6 +269,7 @@ class RhizaTemplate:
             template_host=config.get("template-host", "github"),
             include=_normalize_to_list(config.get("include")),
             exclude=_normalize_to_list(config.get("exclude")),
+            templates=_normalize_to_list(config.get("templates")),
         )
 
     def to_yaml(self, file_path: Path) -> None:
@@ -94,7 +282,7 @@ class RhizaTemplate:
         file_path.parent.mkdir(parents=True, exist_ok=True)
 
         # Convert to dictionary with YAML-compatible keys
-        config = {}
+        config: dict[str, Any] = {}
 
         # Only include template-repository if it's not None
         if self.template_repository:
@@ -108,8 +296,13 @@ class RhizaTemplate:
         if self.template_host and self.template_host != "github":
             config["template-host"] = self.template_host
 
-        # Include is always present as it's a required field for the config to be useful
-        config["include"] = self.include
+        # Write templates if present
+        if self.templates:
+            config["templates"] = self.templates
+
+        # Write include if present (can coexist with templates)
+        if self.include:
+            config["include"] = self.include
 
         # Only include exclude if it's not empty
         if self.exclude:

{rhiza-0.9.0.dist-info → rhiza-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhiza
-Version: 0.9.0
+Version: 0.10.0
 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
@@ -29,7 +29,7 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-# <img src="https://raw.githubusercontent.com/Jebel-Quant/rhiza/main/assets/rhiza-logo.svg" alt="Rhiza Logo" width="30" style="vertical-align: middle;"> rhiza-cli
+# <img src="https://raw.githubusercontent.com/Jebel-Quant/rhiza/main/.rhiza/assets/rhiza-logo.svg" alt="Rhiza Logo" width="30" style="vertical-align: middle;"> rhiza-cli
 ![Synced with Rhiza](https://img.shields.io/badge/synced%20with-rhiza-2FA4A9?color=2FA4A9)
 
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)

rhiza-0.10.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+rhiza/__init__.py,sha256=4-Dy7AKbJneQNBfv30WhSsUin4y-g4Yp4veO6-YdjVg,1926
+rhiza/__main__.py,sha256=GlTahVC8F6fKEpMw_nZyhp4PB-fyC9UQ_RjTZcpD9P4,837
+rhiza/bundle_resolver.py,sha256=_gF2LQqvYfwMCbMKBvlyPr6vfo92463LB6zu948jPu4,2230
+rhiza/cli.py,sha256=y2qzFbrd29-j5OXslM96hZB9vDLvLv5FBnR9SnDdQWE,10613
+rhiza/models.py,sha256=kyrrcbVm5XeceQIY1Ug83TLd2Dd5R725ulOf-VB86yI,10803
+rhiza/subprocess_utils.py,sha256=Pr5TysIKP76hc64fmqhTd6msMGn5DU43hOSR_v_GFb8,745
+rhiza/_templates/basic/__init__.py.jinja2,sha256=gs8qN4LAKcdFd6iO9gZVLuVetODmZP_TGuEjWrbinC0,27
+rhiza/_templates/basic/main.py.jinja2,sha256=uTCahxf9Bftao1IghHue4cSZ9YzBYmBEXeIhEmK9UXQ,362
+rhiza/_templates/basic/pyproject.toml.jinja2,sha256=Mizpnnd_kFQd-pCWOxG-KWhvg4_ZhZaQppTt2pz0WOc,695
+rhiza/commands/__init__.py,sha256=DV1nlcXxeeHXmHobVcfOsGeiZBZ55Xz1mud073AXDGc,1839
+rhiza/commands/init.py,sha256=fD_Nc-EtNo9Fb0PVRLkN2RYMteVv_BUTinAa2jz0_Q4,10745
+rhiza/commands/materialize.py,sha256=oR3OP6vhLlbKPqtFahCyLFCFDksbumNSy6C8KZ2bD44,22229
+rhiza/commands/migrate.py,sha256=A5t4nw7CrdtILCwuSoAqtmM0LpMK8KmX87gzlNgi7fQ,7522
+rhiza/commands/summarise.py,sha256=vgc7M3dwuGjUuVs3XKQr2_g3qURnQH_R3eFoSSrnOro,11758
+rhiza/commands/uninstall.py,sha256=6oO7kdv11Bq4JXjrBg9rsFtoRgttQ4m30zGr6NhZrkQ,7479
+rhiza/commands/validate.py,sha256=_yGx7ARk5K4hqfwzPpJg_7JoG4un0lqHJYJU-4cmYvI,13948
+rhiza/commands/welcome.py,sha256=VknKaUh-bD6dM-zcD1eP4H-D_npyezpfF3bTSl_0Dio,2383
+rhiza-0.10.0.dist-info/METADATA,sha256=T96351Csc2Tu1s75Z57aRJ1JDqZqax5PXr4xZ3BDWCQ,26306
+rhiza-0.10.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rhiza-0.10.0.dist-info/entry_points.txt,sha256=NAwZUpbXvfKv50a_Qq-PxMHl3lcjAyZO63IBeuUNgfY,45
+rhiza-0.10.0.dist-info/licenses/LICENSE,sha256=4m5X7LhqX-6D0Ks79Ys8CLpmza8cxDG34g4S9XSNAGY,1077
+rhiza-0.10.0.dist-info/RECORD,,

rhiza-0.9.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-rhiza/__init__.py,sha256=4-Dy7AKbJneQNBfv30WhSsUin4y-g4Yp4veO6-YdjVg,1926
-rhiza/__main__.py,sha256=Q02upTGaJceknkDABdCwq5_vdMdGY8Cg3ej6WZIHs_s,829
-rhiza/cli.py,sha256=uU0tenEgTe0Wz5lIj0SZIeXy5n_9-8xtUMMP_i71CWA,10609
-rhiza/models.py,sha256=f4TT3XPMEE7ciyrpsXllje4eGJRkYOgpZOoFeRC-rVI,4225
-rhiza/subprocess_utils.py,sha256=Pr5TysIKP76hc64fmqhTd6msMGn5DU43hOSR_v_GFb8,745
-rhiza/_templates/basic/__init__.py.jinja2,sha256=gs8qN4LAKcdFd6iO9gZVLuVetODmZP_TGuEjWrbinC0,27
-rhiza/_templates/basic/main.py.jinja2,sha256=uTCahxf9Bftao1IghHue4cSZ9YzBYmBEXeIhEmK9UXQ,362
-rhiza/_templates/basic/pyproject.toml.jinja2,sha256=Mizpnnd_kFQd-pCWOxG-KWhvg4_ZhZaQppTt2pz0WOc,695
-rhiza/commands/__init__.py,sha256=QWEEVvdW3gKV-FpKgHRJL_H8FpQqvfck9JvnFMDz3gY,1834
-rhiza/commands/init.py,sha256=dpLwFbURyndkgw-v4O6gD0gg6ov6q023uOmaWGup2oA,9785
-rhiza/commands/materialize.py,sha256=1YmzlPz9-IxnV4znDZQijZ3cjfbBXdepmps963z4Hsg,18668
-rhiza/commands/migrate.py,sha256=A5t4nw7CrdtILCwuSoAqtmM0LpMK8KmX87gzlNgi7fQ,7522
-rhiza/commands/summarise.py,sha256=KJ8v4lHSbn8AIt3tJM_lSCizzZ2Bv2mqTfI0z7-kyxI,11736
-rhiza/commands/uninstall.py,sha256=6oO7kdv11Bq4JXjrBg9rsFtoRgttQ4m30zGr6NhZrkQ,7479
-rhiza/commands/validate.py,sha256=VriXJxyuhvGJajw0qiAUmXYKRMbpgKiZ5_MMtE6WlSo,10801
-rhiza/commands/welcome.py,sha256=u197cIlY1tXm-CN6YpyUX4Eq06pLeV0hGyNvT35tE8U,2375
-rhiza-0.9.0.dist-info/METADATA,sha256=6AIK6bVC54vxBE0NB9jdLkBuTUcn9W0jod6ixm1-EB0,26298
-rhiza-0.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-rhiza-0.9.0.dist-info/entry_points.txt,sha256=NAwZUpbXvfKv50a_Qq-PxMHl3lcjAyZO63IBeuUNgfY,45
-rhiza-0.9.0.dist-info/licenses/LICENSE,sha256=4m5X7LhqX-6D0Ks79Ys8CLpmza8cxDG34g4S9XSNAGY,1077
-rhiza-0.9.0.dist-info/RECORD,,