rhiza 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

rhiza/_templates/basic/__init__.py.jinja2

@@ -0,0 +1,2 @@
+"""{{ project_name }}."""
+

rhiza/_templates/basic/main.py.jinja2

@@ -0,0 +1,23 @@
+"""Main module for {{ project_name }}."""
+
+
+def say_hello(name: str) -> str:
+    """Say hello to the user.
+
+    Args:
+        name: The name of the user.
+
+    Returns:
+        A greeting string.
+    """
+    return f"Hello, {name}!"
+
+
+def main() -> None:
+    """Execute the main function."""
+    print(say_hello("World"))
+
+
+if __name__ == "__main__":
+    main()
+

rhiza/_templates/basic/pyproject.toml.jinja2

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []
+{% if with_dev_dependencies %}
+
+[project.optional-dependencies]
+dev = [
+    "pytest-cov>=7.0.0",
+    "pytest-html>=4.1.1",
+    "pytest==9.0.2",
+    "pre-commit==4.5.1",
+    "marimo==0.18.4",
+    "pdoc>=16.0.0",
+]
+{% endif %}
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/{{ package_name }}"]
+{% if with_dev_dependencies %}
+
+[tool.deptry]
+# see https://deptry.com/usage/#pep-621-dev-dependency-groups
+pep621_dev_dependency_groups = ["dev"]
+{% endif %}

rhiza/cli.py

@@ -12,6 +12,8 @@ from rhiza import __version__
 from rhiza.commands import init as init_cmd
 from rhiza.commands import materialize as materialize_cmd
 from rhiza.commands import validate as validate_cmd
+from rhiza.commands.migrate import migrate as migrate_cmd
+from rhiza.commands.uninstall import uninstall as uninstall_cmd
 from rhiza.commands.welcome import welcome as welcome_cmd
 
 app = typer.Typer(
@@ -70,14 +72,27 @@ def init(
         dir_okay=True,
         help="Target directory (defaults to current directory)",
     ),
+    project_name: str = typer.Option(
+        None,
+        "--project-name",
+        help="Custom project name (defaults to directory name)",
+    ),
+    package_name: str = typer.Option(
+        None,
+        "--package-name",
+        help="Custom package name (defaults to normalized project name)",
+    ),
+    with_dev_dependencies: bool = typer.Option(
+        False,
+        "--with-dev-dependencies",
+        help="Include development dependencies in pyproject.toml",
+    ),
 ):
     r"""Initialize or validate .github/rhiza/template.yml.
 
-    \b
     Creates a default `.github/rhiza/template.yml` configuration file if one
     doesn't exist, or validates the existing configuration.
 
-    \b
     The default template includes common Python project files:
     - .github (workflows, actions, etc.)
     - .editorconfig
@@ -86,13 +101,17 @@ def init(
     - Makefile
     - pytest.ini
 
-    \b
     Examples:
       rhiza init
       rhiza init /path/to/project
       rhiza init ..
     """
-    init_cmd(target)
+    init_cmd(
+        target,
+        project_name=project_name,
+        package_name=package_name,
+        with_dev_dependencies=with_dev_dependencies,
+    )
 
 
 @app.command()
@@ -115,18 +134,15 @@ def materialize(
 ):
     r"""Inject Rhiza configuration templates into a target repository.
 
-    \b
     Materializes configuration files from the template repository specified
     in .github/rhiza/template.yml into your project. This command:
 
-    \b
     - Reads .github/rhiza/template.yml configuration
     - Performs a sparse clone of the template repository
     - Copies specified files/directories to your project
     - Respects exclusion patterns defined in the configuration
     - Files that already exist will NOT be overwritten unless --force is used.
 
-    \b
     Examples:
         rhiza materialize
         rhiza materialize --branch develop
@@ -152,7 +168,6 @@ def validate(
     Validates the .github/rhiza/template.yml file to ensure it is syntactically
     correct and semantically valid.
 
-    \b
     Performs comprehensive validation:
     - Checks if template.yml exists
     - Validates YAML syntax
@@ -164,7 +179,6 @@ def validate(
 
     Returns exit code 0 on success, 1 on validation failure.
 
-    \b
     Examples:
         rhiza validate
         rhiza validate /path/to/project
@@ -174,6 +188,40 @@ def validate(
         raise typer.Exit(code=1)
 
 
+@app.command()
+def migrate(
+    target: Path = typer.Argument(
+        default=Path("."),  # default to current directory
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Target git repository (defaults to current directory)",
+    ),
+):
+    r"""Migrate project to the new .rhiza folder structure.
+
+    This command helps transition projects to use the new `.rhiza/` folder
+    structure for storing Rhiza state and configuration files. It performs
+    the following migrations:
+
+    - Creates the `.rhiza/` directory in the project root
+    - Moves `.github/rhiza/template.yml` or `.github/template.yml` to `.rhiza/template.yml`
+    - Moves `.rhiza.history` to `.rhiza/history`
+
+    The new `.rhiza/` folder structure separates Rhiza's state and configuration
+    from the `.github/` directory, providing better organization.
+
+    If files already exist in `.rhiza/`, the migration will skip them and leave
+    the old files in place. You can manually remove old files after verifying
+    the migration was successful.
+
+    Examples:
+        rhiza migrate
+        rhiza migrate /path/to/project
+    """
+    migrate_cmd(target)
+
+
 @app.command()
 def welcome():
     r"""Display a friendly welcome message and explain what Rhiza is.
@@ -181,8 +229,48 @@ def welcome():
     Shows a welcome message, explains Rhiza's purpose, key features,
     and provides guidance on getting started with the tool.
 
-    \b
     Examples:
         rhiza welcome
     """
     welcome_cmd()
+
+
+@app.command()
+def uninstall(
+    target: Path = typer.Argument(
+        default=Path("."),  # default to current directory
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Target git repository (defaults to current directory)",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-y",
+        help="Skip confirmation prompt and proceed with deletion",
+    ),
+):
+    r"""Remove all Rhiza-managed files from the repository.
+
+    Reads the `.rhiza.history` file and removes all files that were
+    previously materialized by Rhiza templates. This provides a clean
+    way to uninstall all template-managed files from a project.
+
+    The command will:
+    - Read the list of files from `.rhiza.history`
+    - Prompt for confirmation (unless --force is used)
+    - Delete all listed files that exist
+    - Remove empty directories left behind
+    - Delete the `.rhiza.history` file itself
+
+    Use this command when you want to completely remove Rhiza templates
+    from your project.
+
+    Examples:
+        rhiza uninstall
+        rhiza uninstall --force
+        rhiza uninstall /path/to/project
+        rhiza uninstall /path/to/project -y
+    """
+    uninstall_cmd(target, force)

rhiza/commands/init.py

@@ -5,16 +5,47 @@ This module provides the init command that creates or validates the
 and what paths are governed by Rhiza.
 """
 
-import shutil
+import importlib.resources
+import keyword
+import re
 from pathlib import Path
 
+from jinja2 import Template
 from loguru import logger
 
 from rhiza.commands.validate import validate
 from rhiza.models import RhizaTemplate
 
 
-def init(target: Path):
+def _normalize_package_name(name: str) -> str:
+    """Normalize a string into a valid Python package name.
+
+    Args:
+        name: The input string (e.g., project name).
+
+    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 init(
+    target: Path,
+    project_name: str | None = None,
+    package_name: str | None = None,
+    with_dev_dependencies: bool = False,
+):
     """Initialize or validate .github/rhiza/template.yml in the target repository.
 
     Creates a default .github/rhiza/template.yml file if it doesn't exist,
@@ -22,6 +53,9 @@ def init(target: Path):
 
     Args:
         target: Path to the target directory. Defaults to the current working directory.
+        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.
 
     Returns:
         bool: True if validation passes, False otherwise.
@@ -31,29 +65,18 @@ def init(target: Path):
 
     logger.info(f"Initializing Rhiza configuration in: {target}")
 
-    # Create .github/rhiza directory structure if it doesn't exist
+    # Create .rhiza directory structure if it doesn't exist
     # This is where Rhiza stores its configuration
-    github_dir = target / ".github"
-    rhiza_dir = github_dir / "rhiza"
+    rhiza_dir = target / ".rhiza"
     logger.debug(f"Ensuring directory exists: {rhiza_dir}")
     rhiza_dir.mkdir(parents=True, exist_ok=True)
 
-    # Check for old location and migrate if necessary
-    # TODO: This migration logic can be removed in a future version
-    # after users have had time to migrate
-    template_file = github_dir / "template.yml"
-    if template_file.exists():
-        logger.warning(f"Found template.yml in old location: {template_file}")
-        logger.info(f"Copying to new location: {rhiza_dir / 'template.yml'}")
-        # Copy the file to the new location (not move, to preserve old one temporarily)
-        shutil.copyfile(template_file, rhiza_dir / "template.yml")
-
-    # Define the template file path (new location)
+    # Define the template file path
     template_file = rhiza_dir / "template.yml"
 
     if not template_file.exists():
         # Create default template.yml with sensible defaults
-        logger.info("Creating default .github/rhiza/template.yml")
+        logger.info("Creating default .rhiza/template.yml")
         logger.debug("Using default template configuration")
 
         # Default template points to the jebel-quant/rhiza repository
@@ -66,6 +89,7 @@ def init(target: Path):
                 ".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
@@ -78,21 +102,27 @@ def init(target: Path):
         logger.debug(f"Writing default template to: {template_file}")
         default_template.to_yaml(template_file)
 
-        logger.success("✓ Created .github/rhiza/template.yml")
+        logger.success("✓ Created .rhiza/template.yml")
         logger.info("""
 Next steps:
-  1. Review and customize .github/rhiza/template.yml to match your project needs
+  1. Review and customize .rhiza/template.yml to match your project needs
   2. Run 'rhiza materialize' to inject templates into your repository
 """)
 
     # Bootstrap basic Python project structure if it doesn't exist
     # Get the name of the parent directory to use as package name
-    parent = target.parent.name
-    logger.debug(f"Parent directory name: {parent}")
+    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/{parent} directory structure following src-layout
-    src_folder = target / "src" / parent
-    if not src_folder.exists():
+    # 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)
 
@@ -101,22 +131,22 @@ Next steps:
         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
-        code = """\
-        def say_hello(name: str) -> str:
-            return f"Hello, {name}!"
-
-        def main():
-            print(say_hello("World"))
-
-        if __name__ == "__main__":
-            main()
-        """
+        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}")
 
@@ -128,15 +158,15 @@ Next steps:
         pyproject_file.touch()
 
         # Write minimal pyproject.toml content
-        code = f'''\
-        [project]
-        name = "{parent}"
-        version = "0.1.0"
-        description = "Add your description here"
-        readme = "README.md"
-        requires-python = ">=3.11"
-        dependencies = []
-        '''
+        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")
 

rhiza/commands/materialize.py

@@ -3,7 +3,7 @@
 This module implements the `materialize` command. It performs a sparse
 checkout of the configured template repository, copies the selected files
 into the target Git repository, and records managed files in
-`.rhiza.history`. Use this to take a one-shot snapshot of template files.
+`.rhiza/history`. Use this to take a one-shot snapshot of template files.
 """
 
 import os
@@ -54,7 +54,7 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
 
     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`.
+    template control in `.rhiza/history`.
 
     Args:
         target (Path): Path to the target repository.
@@ -128,8 +128,21 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         sys.exit(1)
 
     # Load the template configuration from the validated file
-    template_file = target / ".github" / "rhiza" / "template.yml"
-    logger.debug(f"Loading template configuration from: {template_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)
+
     template = RhizaTemplate.from_yaml(template_file)
 
     # Extract template configuration settings
@@ -323,13 +336,26 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
     # -----------------------
     # Clean up orphaned files
     # -----------------------
-    # Read the old .rhiza.history file to find files that are no longer
+    # Read the old history file to find files that are no longer
     # part of the current materialization and should be deleted
-    history_file = target / ".rhiza.history"
+    # Check both new and old locations for backward compatibility
+    new_history_file = target / ".rhiza" / "history"
+    old_history_file = target / ".rhiza.history"
+
+    # Prefer new location, but check old location 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)}")
+    elif old_history_file.exists():
+        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")
+
     previously_tracked_files: set[Path] = set()
 
     if history_file.exists():
-        logger.debug("Reading existing .rhiza.history file")
         with history_file.open("r", encoding="utf-8") as f:
             for line in f:
                 line = line.strip()
@@ -337,7 +363,7 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
                 if line and not line.startswith("#"):
                     previously_tracked_files.add(Path(line))
 
-        logger.debug(f"Found {len(previously_tracked_files)} file(s) in previous .rhiza.history")
+        logger.debug(f"Found {len(previously_tracked_files)} file(s) in previous history")
 
     # Convert materialized_files list to a set for comparison
     currently_materialized_files = set(materialized_files)
@@ -361,11 +387,17 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
         logger.debug("No orphaned files to clean up")
 
     # -----------------------
-    # Write .rhiza.history
+    # Write history file
     # -----------------------
     # This file tracks which files were materialized by Rhiza
     # Useful for understanding which files came from the template
-    logger.debug("Writing .rhiza.history file")
+    # Always write to new location (.rhiza/history)
+    history_file = target / ".rhiza" / "history"
+
+    # Ensure .rhiza directory exists
+    history_file.parent.mkdir(parents=True, exist_ok=True)
+
+    logger.debug(f"Writing history file: {history_file.relative_to(target)}")
     with history_file.open("w", encoding="utf-8") as f:
         f.write("# Rhiza Template History\n")
         f.write("# This file lists all files managed by the Rhiza template.\n")
@@ -379,6 +411,15 @@ def materialize(target: Path, branch: str, target_branch: str | None, force: boo
 
     logger.info(f"Updated {history_file.relative_to(target)} with {len(materialized_files)} file(s)")
 
+    # Clean up old history file if it exists (migration)
+    old_history_file = target / ".rhiza.history"
+    if old_history_file.exists() and old_history_file != history_file:
+        try:
+            old_history_file.unlink()
+            logger.debug(f"Removed old history file: {old_history_file.relative_to(target)}")
+        except Exception as e:
+            logger.warning(f"Could not remove old history file: {e}")
+
     logger.success("Rhiza templates materialized successfully")
 
     logger.info(

rhiza/commands/migrate.py

@@ -0,0 +1,128 @@
+"""Command for migrating to the new .rhiza folder structure.
+
+This module implements the `migrate` command. It helps transition projects to use
+the new `.rhiza/` folder structure for storing Rhiza state and configuration files,
+separate from `.github/rhiza/` which contains template configuration.
+"""
+
+import shutil
+from pathlib import Path
+
+from loguru import logger
+
+
+def migrate(target: Path) -> None:
+    """Migrate project to use the new .rhiza folder structure.
+
+    This command performs the following actions:
+    1. Creates the `.rhiza/` directory in the project root
+    2. Moves template.yml from `.github/rhiza/` or `.github/` to `.rhiza/template.yml`
+    3. Moves `.rhiza.history` to `.rhiza/history` if it exists
+    4. Provides instructions for next steps
+
+    The `.rhiza/` folder will contain:
+    - `template.yml` - Template configuration (replaces `.github/rhiza/template.yml`)
+    - `history` - List of files managed by Rhiza templates (replaces `.rhiza.history`)
+    - Future: Additional state, cache, or metadata files
+
+    Args:
+        target (Path): Path to the target repository.
+    """
+    # Resolve to absolute path
+    target = target.resolve()
+
+    logger.info(f"Migrating Rhiza structure in: {target}")
+    logger.info("This will create the .rhiza folder and migrate configuration files")
+
+    # Create .rhiza directory
+    rhiza_dir = target / ".rhiza"
+    if not rhiza_dir.exists():
+        logger.info(f"Creating .rhiza directory at: {rhiza_dir.relative_to(target)}")
+        rhiza_dir.mkdir(exist_ok=True)
+        logger.success(f"✓ Created {rhiza_dir.relative_to(target)}")
+    else:
+        logger.debug(f".rhiza directory already exists at: {rhiza_dir.relative_to(target)}")
+
+    # Track what was migrated for summary
+    migrations_performed = []
+
+    # Migrate template.yml from .github to .rhiza if it exists
+    github_dir = target / ".github"
+    new_template_file = rhiza_dir / "template.yml"
+
+    # Check possible locations for template.yml in .github
+    possible_template_locations = [
+        github_dir / "rhiza" / "template.yml",
+        github_dir / "template.yml",
+    ]
+
+    template_migrated = False
+    for old_template_file in possible_template_locations:
+        if old_template_file.exists():
+            if new_template_file.exists():
+                logger.info(".rhiza/template.yml already exists")
+                logger.info(f"Skipping migration of {old_template_file.relative_to(target)}")
+                logger.info(f"Note: Old file at {old_template_file.relative_to(target)} still exists")
+            else:
+                logger.info(f"Found template.yml at: {old_template_file.relative_to(target)}")
+                logger.info(f"Moving to new location: {new_template_file.relative_to(target)}")
+
+                # Move the template file to new location (not copy)
+                shutil.move(str(old_template_file), str(new_template_file))
+                logger.success("✓ Moved template.yml to .rhiza/template.yml")
+                migrations_performed.append("Moved template.yml to .rhiza/template.yml")
+                template_migrated = True
+            break
+
+    if not template_migrated:
+        if new_template_file.exists():
+            logger.info(".rhiza/template.yml already exists (no migration needed)")
+        else:
+            logger.warning("No existing template.yml file found in .github")
+            logger.info("You may need to run 'rhiza init' to create a template configuration")
+
+    # Migrate .rhiza.history to .rhiza/history if it exists
+    old_history_file = target / ".rhiza.history"
+    new_history_file = rhiza_dir / "history"
+
+    if old_history_file.exists():
+        if new_history_file.exists():
+            logger.info(".rhiza/history already exists")
+            logger.info(f"Skipping migration of {old_history_file.relative_to(target)}")
+            logger.info(f"Note: Old file at {old_history_file.relative_to(target)} still exists")
+        else:
+            logger.info("Found existing .rhiza.history file")
+            logger.info(f"Moving to new location: {new_history_file.relative_to(target)}")
+
+            # Move the history file to new location
+            shutil.move(str(old_history_file), str(new_history_file))
+            logger.success("✓ Moved history file to .rhiza/history")
+            migrations_performed.append("Moved history tracking to .rhiza/history")
+    else:
+        if new_history_file.exists():
+            logger.debug(".rhiza/history already exists (no migration needed)")
+        else:
+            logger.debug("No existing .rhiza.history file to migrate")
+
+    # Summary
+    logger.success("✓ Migration completed successfully")
+
+    if migrations_performed:
+        logger.info("\nMigration Summary:")
+        logger.info("  - Created .rhiza/ folder")
+        for migration in migrations_performed:
+            logger.info(f"  - {migration}")
+    else:
+        logger.info("\nNo files needed migration (already using .rhiza structure)")
+
+    logger.info(
+        "\nNext steps:\n"
+        "  1. Review changes:\n"
+        "       git status\n"
+        "       git diff\n\n"
+        "  2. Update other commands to use new .rhiza/ location\n"
+        "     (Future rhiza versions will automatically use .rhiza/)\n\n"
+        "  3. Commit the migration:\n"
+        "       git add .\n"
+        '       git commit -m "chore: migrate to .rhiza folder structure"\n'
+    )

rhiza/commands/uninstall.py

@@ -0,0 +1,151 @@
+"""Command for uninstalling Rhiza template files from a repository.
+
+This module implements the `uninstall` command. It reads the `.rhiza/history`
+file and removes all files that were previously materialized by Rhiza templates.
+This provides a clean way to remove all template-managed files from a project.
+"""
+
+import sys
+from pathlib import Path
+
+from loguru import logger
+
+
+def uninstall(target: Path, force: bool) -> None:
+    """Uninstall Rhiza templates from the target repository.
+
+    Reads the `.rhiza/history` file and removes all files listed in it.
+    This effectively removes all files that were materialized by Rhiza.
+
+    Args:
+        target (Path): Path to the target repository.
+        force (bool): If True, skip confirmation prompt and proceed with deletion.
+    """
+    # Resolve to absolute path to avoid any ambiguity
+    target = target.resolve()
+
+    logger.info(f"Target repository: {target}")
+
+    # Check for history file in new location only
+    history_file = target / ".rhiza" / "history"
+
+    if not history_file.exists():
+        logger.warning(f"No history file found at: {history_file.relative_to(target)}")
+        logger.info("Nothing to uninstall. This repository may not have Rhiza templates materialized.")
+        logger.info("If you haven't migrated yet, run 'rhiza migrate' first.")
+        return
+
+    # Read the history file
+    logger.debug(f"Reading history file: {history_file.relative_to(target)}")
+    files_to_remove: list[Path] = []
+
+    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("#"):
+                file_path = Path(line)
+                files_to_remove.append(file_path)
+
+    if not files_to_remove:
+        logger.warning("History file is empty (only contains comments)")
+        logger.info("Nothing to uninstall.")
+        return
+
+    logger.info(f"Found {len(files_to_remove)} file(s) to remove")
+
+    # Show confirmation prompt unless --force is used
+    if not force:
+        logger.warning("This will remove the following files from your repository:")
+        for file_path in sorted(files_to_remove):
+            full_path = target / file_path
+            if full_path.exists():
+                logger.warning(f"  - {file_path}")
+            else:
+                logger.debug(f"  - {file_path} (already deleted)")
+
+        # Prompt for confirmation
+        try:
+            response = input("\nAre you sure you want to proceed? [y/N]: ").strip().lower()
+            if response not in ("y", "yes"):
+                logger.info("Uninstall cancelled by user")
+                return
+        except (KeyboardInterrupt, EOFError):
+            logger.info("\nUninstall cancelled by user")
+            return
+
+    # Remove files
+    logger.info("Removing files...")
+    removed_count = 0
+    skipped_count = 0
+    error_count = 0
+
+    for file_path in sorted(files_to_remove):
+        full_path = target / file_path
+
+        if not full_path.exists():
+            logger.debug(f"[SKIP] {file_path} (already deleted)")
+            skipped_count += 1
+            continue
+
+        try:
+            full_path.unlink()
+            logger.success(f"[DEL] {file_path}")
+            removed_count += 1
+        except Exception as e:
+            logger.error(f"Failed to delete {file_path}: {e}")
+            error_count += 1
+
+    # Clean up empty directories
+    logger.debug("Cleaning up empty directories...")
+    empty_dirs_removed = 0
+    for file_path in sorted(files_to_remove, reverse=True):
+        full_path = target / file_path
+        parent = full_path.parent
+
+        # Try to remove parent directories if they're empty
+        # Walk up the directory tree
+        while parent != target and parent.exists():
+            try:
+                # Only remove if directory is empty
+                if parent.is_dir() and not any(parent.iterdir()):
+                    parent.rmdir()
+                    logger.debug(f"[DEL] {parent.relative_to(target)}/ (empty directory)")
+                    empty_dirs_removed += 1
+                    parent = parent.parent
+                else:
+                    break
+            except Exception:
+                # Directory not empty or other error, stop walking up
+                break
+
+    # Remove history file itself
+    try:
+        history_file.unlink()
+        logger.success(f"[DEL] {history_file.relative_to(target)}")
+        removed_count += 1
+    except Exception as e:
+        logger.error(f"Failed to delete {history_file.relative_to(target)}: {e}")
+        error_count += 1
+
+    # Summary
+    logger.info("\nUninstall summary:")
+    logger.info(f"  Files removed: {removed_count}")
+    if skipped_count > 0:
+        logger.info(f"  Files skipped (already deleted): {skipped_count}")
+    if empty_dirs_removed > 0:
+        logger.info(f"  Empty directories removed: {empty_dirs_removed}")
+    if error_count > 0:
+        logger.error(f"  Errors encountered: {error_count}")
+        sys.exit(1)
+
+    logger.success("Rhiza templates uninstalled successfully")
+    logger.info(
+        "Next steps:\n"
+        "  Review changes:\n"
+        "    git status\n"
+        "    git diff\n\n"
+        "  Commit:\n"
+        "    git add .\n"
+        '    git commit -m "chore: remove rhiza templates"'
+    )

rhiza/commands/validate.py

@@ -1,7 +1,7 @@
 """Command for validating Rhiza template configuration.
 
-This module provides functionality to validate .github/rhiza/template.yml files
-to ensure they are syntactically correct and semantically valid.
+This module provides functionality to validate template.yml files in the
+.rhiza/template.yml location (new standard location after migration).
 """
 
 from pathlib import Path
@@ -14,6 +14,9 @@ def validate(target: Path) -> bool:
     """Validate template.yml configuration in the target repository.
 
     Performs authoritative validation of the template configuration:
+    - Checks if target is a git repository
+    - Checks for standard project structure (src and tests folders)
+    - Checks for pyproject.toml (required)
     - Checks if template.yml exists
     - Validates YAML syntax
     - Validates required fields
@@ -37,30 +40,51 @@ def validate(target: Path) -> bool:
 
     logger.info(f"Validating template configuration in: {target}")
 
-    # Check for template.yml in both new and old locations
-    # New location: .github/rhiza/template.yml
-    # Old location: .github/template.yml (deprecated but still supported)
-    new_location = target / ".github" / "rhiza" / "template.yml"
-    deprecated_location = target / ".github" / "template.yml"
+    # Check for standard project structure (src and tests folders)
+    logger.debug("Validating project structure")
+    src_dir = target / "src"
+    tests_dir = target / "tests"
 
-    # Check which file(s) exist
-    new_exists = new_location.exists()
-    deprecated_exists = deprecated_location.exists()
+    if not src_dir.exists():
+        logger.warning(f"Standard 'src' folder not found: {src_dir}")
+        logger.warning("Consider creating a 'src' directory for source code")
+    else:
+        logger.success(f"'src' folder exists: {src_dir}")
 
-    if not (new_exists or deprecated_exists):
-        logger.error(f"No template file found at: {new_location}")
-        logger.error(f"Also checked deprecated location: {deprecated_location}")
-        logger.info("Run 'rhiza init' to create a default template.yml")
-        return False
+    if not tests_dir.exists():
+        logger.warning(f"Standard 'tests' folder not found: {tests_dir}")
+        logger.warning("Consider creating a 'tests' directory for test files")
+    else:
+        logger.success(f"'tests' folder exists: {tests_dir}")
+
+    # Check for pyproject.toml - this is always required
+    logger.debug("Validating pyproject.toml")
+    pyproject_file = target / "pyproject.toml"
 
-    # Prefer the new location but support the old one with a warning
-    if new_exists:
-        logger.success(f"Template file exists: {new_location}")
-        template_file = new_location
+    if not pyproject_file.exists():
+        logger.error(f"pyproject.toml not found: {pyproject_file}")
+        logger.error("pyproject.toml is required for Python projects")
+        logger.info("Run 'rhiza init' to create a default pyproject.toml")
+        return False
     else:
-        logger.warning(f"Template file exists but in old location: {deprecated_location}")
-        logger.warning("Consider moving it to .github/rhiza/template.yml")
-        template_file = deprecated_location
+        logger.success(f"pyproject.toml exists: {pyproject_file}")
+
+    # Check for template.yml in new location only
+    template_file = target / ".rhiza" / "template.yml"
+
+    if not template_file.exists():
+        logger.error(f"No template file found at: {template_file.relative_to(target)}")
+        logger.error("The template configuration must be in the .rhiza folder.")
+        logger.info("")
+        logger.info("To fix this:")
+        logger.info("  • If you're starting fresh, run: rhiza init")
+        logger.info("  • If you have an existing configuration, run: rhiza migrate")
+        logger.info("")
+        logger.info("The 'rhiza migrate' command will move your configuration from")
+        logger.info("  .github/rhiza/template.yml → .rhiza/template.yml")
+        return False
+
+    logger.success(f"Template file exists: {template_file.relative_to(target)}")
 
     # Validate YAML syntax by attempting to parse the file
     logger.debug(f"Parsing YAML file: {template_file}")

{rhiza-0.7.0.dist-info → rhiza-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhiza
-Version: 0.7.0
+Version: 0.8.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
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.11
+Requires-Dist: jinja2>=3.1.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: typer>=0.20.0
@@ -60,6 +61,7 @@ Rhiza is a CLI tool that helps you maintain consistent configuration across mult
 - [Commands](#commands)
   - [init](#rhiza-init)
   - [materialize](#rhiza-materialize)
+  - [migrate](#rhiza-migrate)
   - [validate](#rhiza-validate)
 - [Configuration](#configuration)
 - [Examples](#examples)
@@ -316,6 +318,86 @@ Re-run this script to update templates explicitly.
 
 ---
 
+### `rhiza migrate`
+
+Migrate project to the new `.rhiza` folder structure.
+
+**Usage:**
+
+```bash
+rhiza migrate [OPTIONS] [TARGET]
+```
+
+**Arguments:**
+
+- `TARGET` - Target git repository directory (defaults to current directory)
+
+**Arguments:**
+
+- `TARGET` - Target git repository directory (defaults to current directory)
+
+**Description:**
+
+Migrates your project to use the new `.rhiza/` folder structure for storing Rhiza state and configuration files. This command helps transition from the old structure where configuration was stored in `.github/rhiza/` and `.rhiza.history` in the project root.
+
+The migration performs the following actions:
+
+1. Creates the `.rhiza/` directory in the project root
+2. Moves `template.yml` from `.github/rhiza/` or `.github/` to `.rhiza/template.yml`
+3. Moves `.rhiza.history` to `.rhiza/history`
+4. Provides instructions for next steps
+
+The new `.rhiza/` folder structure provides better organization by separating Rhiza's state and configuration from the `.github/` directory.
+
+**Examples:**
+
+```bash
+# Migrate current directory
+rhiza migrate
+
+# Migrate a specific directory
+rhiza migrate /path/to/project
+```
+
+**Output:**
+
+```
+[INFO] Migrating Rhiza structure in: /path/to/project
+[INFO] This will create the .rhiza folder and migrate configuration files
+[INFO] Creating .rhiza directory at: .rhiza
+✓ Created .rhiza
+[INFO] Found template.yml at: .github/rhiza/template.yml
+[INFO] Moving to new location: .rhiza/template.yml
+✓ Moved template.yml to .rhiza/template.yml
+✓ Migration completed successfully
+
+Migration Summary:
+  - Created .rhiza/ folder
+  - Moved template.yml to .rhiza/template.yml
+  - Moved history tracking to .rhiza/history
+
+Next steps:
+  1. Review changes:
+       git status
+       git diff
+
+  2. Update other commands to use new .rhiza/ location
+     (Future rhiza versions will automatically use .rhiza/)
+
+  3. Commit the migration:
+       git add .
+       git commit -m "chore: migrate to .rhiza folder structure"
+```
+
+**Notes:**
+
+- If files already exist in `.rhiza/`, the migration will skip them and leave the old files in place
+- You can manually remove old files after verifying the migration was successful
+- The old `.rhiza.history` file is removed after successful migration to `.rhiza/history`
+- The original template file in `.github/` is moved (removed from old location)
+
+---
+
 ### `rhiza validate`
 
 Validate Rhiza template configuration.

rhiza-0.8.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+rhiza/__init__.py,sha256=iW3niLBjwRKxcMhIV_1eb78putjUTo2tbZsadofluJk,1939
+rhiza/__main__.py,sha256=Lx0GqVZo6ymm0f18_uYB6E7_SOWwJNYjb73Vr31oLoM,236
+rhiza/cli.py,sha256=I5A5d1-3xrL2gdh5H9Itm9uiQjoPiGEbHYyxXddHEOk,8196
+rhiza/models.py,sha256=fW9lofkkid-bghk2bXEgBdGbZ4scSqG726fMrVfKX_M,3454
+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=Z5CeMh7ylX27H6dvwqRbEKzYo5pwQq-5TyTxABUSaQg,1848
+rhiza/commands/init.py,sha256=RsYmomOq-00b4bAjseiHR7ljgJQ_XSjDX-ZWKYTPPN8,6787
+rhiza/commands/materialize.py,sha256=kzcpiKDN0HZQylZW-TZVlrJJctHnmBxq2JQQcNGyOV8,17951
+rhiza/commands/migrate.py,sha256=Zlu-Oq4MJCW3jcKqB2v1-wV3zEr2s6AqYV_btvGOjCE,5425
+rhiza/commands/uninstall.py,sha256=z95xqamV7wGPr8PBveWzaRmtD5bPhOrTLI0GcOvpnAo,5371
+rhiza/commands/validate.py,sha256=1HMQWF9Syv7JKC31AkaPYMTnqy8HOvAMxMLrYty36FQ,9112
+rhiza/commands/welcome.py,sha256=w3BziR042o6oYincd3EqDsFzF6qqInU7iYhWjF3yJqY,2382
+rhiza-0.8.0.dist-info/METADATA,sha256=k_wVNzEknv4GiXwVCxmeUvQ8ex0OXDVsfOkiWELyI9g,25156
+rhiza-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+rhiza-0.8.0.dist-info/entry_points.txt,sha256=NAwZUpbXvfKv50a_Qq-PxMHl3lcjAyZO63IBeuUNgfY,45
+rhiza-0.8.0.dist-info/licenses/LICENSE,sha256=4m5X7LhqX-6D0Ks79Ys8CLpmza8cxDG34g4S9XSNAGY,1077
+rhiza-0.8.0.dist-info/RECORD,,

rhiza-0.7.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-rhiza/__init__.py,sha256=iW3niLBjwRKxcMhIV_1eb78putjUTo2tbZsadofluJk,1939
-rhiza/__main__.py,sha256=Lx0GqVZo6ymm0f18_uYB6E7_SOWwJNYjb73Vr31oLoM,236
-rhiza/cli.py,sha256=faCIOKDzEDRvL4doLZhiIAyHUUGESGrwWLtjLjimCUY,5111
-rhiza/models.py,sha256=fW9lofkkid-bghk2bXEgBdGbZ4scSqG726fMrVfKX_M,3454
-rhiza/commands/__init__.py,sha256=Z5CeMh7ylX27H6dvwqRbEKzYo5pwQq-5TyTxABUSaQg,1848
-rhiza/commands/init.py,sha256=Hrox_o8hnyWMkx4SuE0rd4jqGIBEl_V_wh7BAiW9IFU,5726
-rhiza/commands/materialize.py,sha256=jmXH9Fb3lkktxgdWtZ2cQk0wyURleWzHvQN6n_DNZ7U,16049
-rhiza/commands/validate.py,sha256=cxStfXbY_ifsc_yRDCg0TOnv8jG05hxE9rteta-X9hQ,8093
-rhiza/commands/welcome.py,sha256=w3BziR042o6oYincd3EqDsFzF6qqInU7iYhWjF3yJqY,2382
-rhiza-0.7.0.dist-info/METADATA,sha256=00UAERh_SGq5WoD8xZsbl83SdNZBO8QjBCP0Al-qQKM,22742
-rhiza-0.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-rhiza-0.7.0.dist-info/entry_points.txt,sha256=NAwZUpbXvfKv50a_Qq-PxMHl3lcjAyZO63IBeuUNgfY,45
-rhiza-0.7.0.dist-info/licenses/LICENSE,sha256=4m5X7LhqX-6D0Ks79Ys8CLpmza8cxDG34g4S9XSNAGY,1077
-rhiza-0.7.0.dist-info/RECORD,,