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

rhiza/__main__.py

@@ -4,7 +4,29 @@ This module allows running the Rhiza CLI with `python -m rhiza` by
 delegating execution to the Typer application defined in `rhiza.cli`.
 """
 
+from importlib.metadata import entry_points
+
+import typer
+
 from rhiza.cli import app
 
+
+def load_plugins(app: typer.Typer):
+    """Load plugins from entry points."""
+    # 'rhiza.plugins' matches the group we defined in rhiza-tools
+    plugin_entries = entry_points(group="rhiza.plugins")
+
+    for entry in plugin_entries:
+        try:
+            plugin_app = entry.load()
+            # This adds the plugin as a subcommand, e.g., 'rhiza tools bump'
+            app.add_typer(plugin_app, name=entry.name)
+        except Exception as e:
+            print(f"Failed to load plugin {entry.name}: {e}")
+
+
+load_plugins(app)
+
+
 if __name__ == "__main__":
     app()

rhiza/cli.py

@@ -87,22 +87,27 @@ def init(
         "--with-dev-dependencies",
         help="Include development dependencies in pyproject.toml",
     ),
+    git_host: str = typer.Option(
+        None,
+        "--git-host",
+        help="Target Git hosting platform (github or gitlab). Determines which CI/CD files to include. "
+        "If not provided, will prompt interactively.",
+    ),
 ):
     r"""Initialize or validate .github/rhiza/template.yml.
 
     Creates a default `.github/rhiza/template.yml` configuration file if one
     doesn't exist, or validates the existing configuration.
 
-    The default template includes common Python project files:
-    - .github (workflows, actions, etc.)
-    - .editorconfig
-    - .gitignore
-    - .pre-commit-config.yaml
-    - Makefile
-    - pytest.ini
+    The default template includes common Python project files.
+    The --git-host option determines which CI/CD configuration to include:
+    - github: includes .github folder (GitHub Actions workflows)
+    - gitlab: includes .gitlab-ci.yml (GitLab CI configuration)
 
     Examples:
       rhiza init
+      rhiza init --git-host github
+      rhiza init --git-host gitlab
       rhiza init /path/to/project
       rhiza init ..
     """
@@ -111,6 +116,7 @@ def init(
         project_name=project_name,
         package_name=package_name,
         with_dev_dependencies=with_dev_dependencies,
+        git_host=git_host,
     )
 
 

rhiza/commands/init.py

@@ -8,8 +8,10 @@ and what paths are governed by Rhiza.
 import importlib.resources
 import keyword
 import re
+import sys
 from pathlib import Path
 
+import typer
 from jinja2 import Template
 from loguru import logger
 
@@ -26,25 +28,221 @@ def _normalize_package_name(name: str) -> str:
     Returns:
         A valid Python identifier safe for use as a package name.
     """
-    # Replace any character that is not a letter, number, or underscore with an underscore
     name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
-
-    # Ensure it doesn't start with a number
     if name[0].isdigit():
         name = f"_{name}"
-
-    # Ensure it's not a Python keyword
     if keyword.iskeyword(name):
         name = f"{name}_"
-
     return name
 
 
+def _validate_git_host(git_host: str | None) -> str | None:
+    """Validate git_host parameter.
+
+    Args:
+        git_host: Git hosting platform.
+
+    Returns:
+        Validated git_host or None.
+
+    Raises:
+        ValueError: If git_host is invalid.
+    """
+    if git_host is not None:
+        git_host = git_host.lower()
+        if git_host not in ["github", "gitlab"]:
+            logger.error(f"Invalid git-host: {git_host}. Must be 'github' or 'gitlab'")
+            raise ValueError(f"Invalid git-host: {git_host}. Must be 'github' or 'gitlab'")
+    return git_host
+
+
+def _prompt_git_host() -> str:
+    """Prompt user for git hosting platform.
+
+    Returns:
+        Git hosting platform choice.
+    """
+    if sys.stdin.isatty():
+        logger.info("Where will your project be hosted?")
+        git_host = typer.prompt(
+            "Target Git hosting platform (github/gitlab)",
+            type=str,
+            default="github",
+        ).lower()
+
+        while git_host not in ["github", "gitlab"]:
+            logger.warning(f"Invalid choice: {git_host}. Please choose 'github' or 'gitlab'")
+            git_host = typer.prompt(
+                "Target Git hosting platform (github/gitlab)",
+                type=str,
+                default="github",
+            ).lower()
+    else:
+        git_host = "github"
+        logger.debug("Non-interactive mode detected, defaulting to github")
+
+    return git_host
+
+
+def _get_include_paths_for_host(git_host: str) -> list[str]:
+    """Get include paths based on git hosting platform.
+
+    Args:
+        git_host: Git hosting platform.
+
+    Returns:
+        List of include paths.
+    """
+    if git_host == "gitlab":
+        return [
+            ".rhiza",
+            ".gitlab",
+            ".gitlab-ci.yml",
+            ".editorconfig",
+            ".gitignore",
+            ".pre-commit-config.yaml",
+            "ruff.toml",
+            "Makefile",
+            "pytest.ini",
+            "book",
+            "presentation",
+            "tests",
+        ]
+    else:
+        return [
+            ".rhiza",
+            ".github",
+            ".editorconfig",
+            ".gitignore",
+            ".pre-commit-config.yaml",
+            "ruff.toml",
+            "Makefile",
+            "pytest.ini",
+            "book",
+            "presentation",
+            "tests",
+        ]
+
+
+def _create_template_file(target: Path, git_host: str) -> None:
+    """Create default template.yml file.
+
+    Args:
+        target: Target repository path.
+        git_host: Git hosting platform.
+    """
+    rhiza_dir = target / ".rhiza"
+    template_file = rhiza_dir / "template.yml"
+
+    if template_file.exists():
+        return
+
+    logger.info("Creating default .rhiza/template.yml")
+    logger.debug("Using default template configuration")
+
+    include_paths = _get_include_paths_for_host(git_host)
+    default_template = RhizaTemplate(
+        template_repository="jebel-quant/rhiza",
+        template_branch="main",
+        include=include_paths,
+    )
+
+    logger.debug(f"Writing default template to: {template_file}")
+    default_template.to_yaml(template_file)
+
+    logger.success("✓ Created .rhiza/template.yml")
+    logger.info("""
+Next steps:
+  1. Review and customize .rhiza/template.yml to match your project needs
+  2. Run 'rhiza materialize' to inject templates into your repository
+""")
+
+
+def _create_python_package(target: Path, project_name: str, package_name: str) -> None:
+    """Create basic Python package structure.
+
+    Args:
+        target: Target repository path.
+        project_name: Project name.
+        package_name: Package name.
+    """
+    src_folder = target / "src" / package_name
+    if (target / "src").exists():
+        return
+
+    logger.info(f"Creating Python package structure: {src_folder}")
+    src_folder.mkdir(parents=True)
+
+    # Create __init__.py
+    init_file = src_folder / "__init__.py"
+    logger.debug(f"Creating {init_file}")
+    init_file.touch()
+
+    template_content = importlib.resources.files("rhiza").joinpath("_templates/basic/__init__.py.jinja2").read_text()
+    template = Template(template_content)
+    code = template.render(project_name=project_name)
+    init_file.write_text(code)
+
+    # Create main.py
+    main_file = src_folder / "main.py"
+    logger.debug(f"Creating {main_file} with example code")
+    main_file.touch()
+
+    template_content = importlib.resources.files("rhiza").joinpath("_templates/basic/main.py.jinja2").read_text()
+    template = Template(template_content)
+    code = template.render(project_name=project_name)
+    main_file.write_text(code)
+    logger.success(f"Created Python package structure in {src_folder}")
+
+
+def _create_pyproject_toml(target: Path, project_name: str, package_name: str, with_dev_dependencies: bool) -> None:
+    """Create pyproject.toml file.
+
+    Args:
+        target: Target repository path.
+        project_name: Project name.
+        package_name: Package name.
+        with_dev_dependencies: Whether to include dev dependencies.
+    """
+    pyproject_file = target / "pyproject.toml"
+    if pyproject_file.exists():
+        return
+
+    logger.info("Creating pyproject.toml with basic project metadata")
+    pyproject_file.touch()
+
+    template_content = importlib.resources.files("rhiza").joinpath("_templates/basic/pyproject.toml.jinja2").read_text()
+    template = Template(template_content)
+    code = template.render(
+        project_name=project_name,
+        package_name=package_name,
+        with_dev_dependencies=with_dev_dependencies,
+    )
+    pyproject_file.write_text(code)
+    logger.success("Created pyproject.toml")
+
+
+def _create_readme(target: Path) -> None:
+    """Create README.md file.
+
+    Args:
+        target: Target repository path.
+    """
+    readme_file = target / "README.md"
+    if readme_file.exists():
+        return
+
+    logger.info("Creating README.md")
+    readme_file.touch()
+    logger.success("Created README.md")
+
+
 def init(
     target: Path,
     project_name: str | None = None,
     package_name: str | None = None,
     with_dev_dependencies: bool = False,
+    git_host: str | None = None,
 ):
     """Initialize or validate .github/rhiza/template.yml in the target repository.
 
@@ -56,130 +254,42 @@ def init(
         project_name: Custom project name. Defaults to target directory name.
         package_name: Custom package name. Defaults to normalized project name.
         with_dev_dependencies: Include development dependencies in pyproject.toml.
+        git_host: Target Git hosting platform ("github" or "gitlab"). Determines which
+            CI/CD configuration files to include. If None, will prompt user interactively.
 
     Returns:
         bool: True if validation passes, False otherwise.
     """
-    # Convert to absolute path to avoid surprises
     target = target.resolve()
+    git_host = _validate_git_host(git_host)
 
     logger.info(f"Initializing Rhiza configuration in: {target}")
 
-    # Create .rhiza directory structure if it doesn't exist
-    # This is where Rhiza stores its configuration
+    # Create .rhiza directory
     rhiza_dir = target / ".rhiza"
     logger.debug(f"Ensuring directory exists: {rhiza_dir}")
     rhiza_dir.mkdir(parents=True, exist_ok=True)
 
-    # Define the template file path
-    template_file = rhiza_dir / "template.yml"
+    # Determine git host
+    if git_host is None:
+        git_host = _prompt_git_host()
 
-    if not template_file.exists():
-        # Create default template.yml with sensible defaults
-        logger.info("Creating default .rhiza/template.yml")
-        logger.debug("Using default template configuration")
-
-        # Default template points to the jebel-quant/rhiza repository
-        # and includes common Python project configuration files
-        default_template = RhizaTemplate(
-            template_repository="jebel-quant/rhiza",
-            template_branch="main",
-            include=[
-                ".rhiza",  # .rhiza folder
-                ".github",  # GitHub configuration and workflows
-                ".editorconfig",  # Editor configuration
-                ".gitignore",  # Git ignore patterns
-                ".pre-commit-config.yaml",  # Pre-commit hooks
-                "ruff.toml",  # Ruff linter configuration
-                "Makefile",  # Build and development tasks
-                "pytest.ini",  # Pytest configuration
-                "book",  # Documentation book
-                "presentation",  # Presentation materials
-                "tests",  # Test structure
-            ],
-        )
-
-        # Write the default template to the file
-        logger.debug(f"Writing default template to: {template_file}")
-        default_template.to_yaml(template_file)
-
-        logger.success("✓ Created .rhiza/template.yml")
-        logger.info("""
-Next steps:
-  1. Review and customize .rhiza/template.yml to match your project needs
-  2. Run 'rhiza materialize' to inject templates into your repository
-""")
+    # Create template file
+    _create_template_file(target, git_host)
 
-    # Bootstrap basic Python project structure if it doesn't exist
-    # Get the name of the parent directory to use as package name
+    # Bootstrap Python project structure
     if project_name is None:
         project_name = target.name
-
     if package_name is None:
         package_name = _normalize_package_name(project_name)
 
     logger.debug(f"Project name: {project_name}")
     logger.debug(f"Package name: {package_name}")
 
-    # Create src/{package_name} directory structure following src-layout
-    src_folder = target / "src" / package_name
-    if not (target / "src").exists():
-        logger.info(f"Creating Python package structure: {src_folder}")
-        src_folder.mkdir(parents=True)
-
-        # Create __init__.py to make it a proper Python package
-        init_file = src_folder / "__init__.py"
-        logger.debug(f"Creating {init_file}")
-        init_file.touch()
-
-        template_content = (
-            importlib.resources.files("rhiza").joinpath("_templates/basic/__init__.py.jinja2").read_text()
-        )
-        template = Template(template_content)
-        code = template.render(project_name=project_name)
-        init_file.write_text(code)
-
-        # Create main.py with a simple "Hello World" example
-        main_file = src_folder / "main.py"
-        logger.debug(f"Creating {main_file} with example code")
-        main_file.touch()
-
-        # Write example code to main.py
-        template_content = importlib.resources.files("rhiza").joinpath("_templates/basic/main.py.jinja2").read_text()
-        template = Template(template_content)
-        code = template.render(project_name=project_name)
-        main_file.write_text(code)
-        logger.success(f"Created Python package structure in {src_folder}")
-
-    # Create pyproject.toml if it doesn't exist
-    # This is the standard Python package metadata file (PEP 621)
-    pyproject_file = target / "pyproject.toml"
-    if not pyproject_file.exists():
-        logger.info("Creating pyproject.toml with basic project metadata")
-        pyproject_file.touch()
-
-        # Write minimal pyproject.toml content
-        template_content = (
-            importlib.resources.files("rhiza").joinpath("_templates/basic/pyproject.toml.jinja2").read_text()
-        )
-        template = Template(template_content)
-        code = template.render(
-            project_name=project_name,
-            package_name=package_name,
-            with_dev_dependencies=with_dev_dependencies,
-        )
-        pyproject_file.write_text(code)
-        logger.success("Created pyproject.toml")
-
-    # Create README.md if it doesn't exist
-    # Every project should have a README
-    readme_file = target / "README.md"
-    if not readme_file.exists():
-        logger.info("Creating README.md")
-        readme_file.touch()
-        logger.success("Created README.md")
+    _create_python_package(target, project_name, package_name)
+    _create_pyproject_toml(target, project_name, package_name, with_dev_dependencies)
+    _create_readme(target)
 
-    # Validate the template file to ensure it's correct
-    # This will catch any issues early
+    # Validate the template file
     logger.debug("Validating template configuration")
     return validate(target)