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

rhiza/commands/migrate.py

@@ -13,30 +13,15 @@ from loguru import logger
 from rhiza.models import RhizaTemplate
 
 
-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
+def _create_rhiza_directory(target: Path) -> Path:
+    """Create .rhiza directory if it doesn't exist.
 
     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")
+        target: Target repository path.
 
-    # Create .rhiza directory
+    Returns:
+        Path to .rhiza directory.
+    """
     rhiza_dir = target / ".rhiza"
     if not rhiza_dir.exists():
         logger.info(f"Creating .rhiza directory at: {rhiza_dir.relative_to(target)}")
@@ -44,21 +29,30 @@ def migrate(target: Path) -> None:
         logger.success(f"✓ Created {rhiza_dir.relative_to(target)}")
     else:
         logger.debug(f".rhiza directory already exists at: {rhiza_dir.relative_to(target)}")
+    return rhiza_dir
 
-    # Track what was migrated for summary
-    migrations_performed = []
 
-    # Migrate template.yml from .github to .rhiza if it exists
+def _migrate_template_file(target: Path, rhiza_dir: Path) -> tuple[bool, list[str]]:
+    """Migrate template.yml from .github to .rhiza.
+
+    Args:
+        target: Target repository path.
+        rhiza_dir: Path to .rhiza directory.
+
+    Returns:
+        Tuple of (migration_performed, migrations_list).
+    """
     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",
     ]
 
+    migrations_performed = []
     template_migrated = False
+
     for old_template_file in possible_template_locations:
         if old_template_file.exists():
             if new_template_file.exists():
@@ -68,8 +62,6 @@ def migrate(target: Path) -> None:
             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")
@@ -83,26 +75,42 @@ def migrate(target: Path) -> None:
             logger.warning("No existing template.yml file found in .github")
             logger.info("You may need to run 'rhiza init' to create a template configuration")
 
-    # Ensure the .rhiza folder is included in template.yml include list (if template exists)
-    template_file = new_template_file
-    if template_file.exists():
-        # Load existing template configuration
-        template = RhizaTemplate.from_yaml(template_file)
-        template_include = template.include or []
-        if ".rhiza" not in template_include:
-            logger.warning("The .rhiza folder is not included in your template.yml")
-            template_include.append(".rhiza")
-            logger.info("The .rhiza folder is added to your template.yml to ensure it's included in your repository")
-
-            # Save the updated template.yml
-            template.include = template_include
-            template.to_yaml(template_file)
-    else:
+    return template_migrated or new_template_file.exists(), migrations_performed
+
+
+def _ensure_rhiza_in_include(template_file: Path) -> None:
+    """Ensure .rhiza folder is in template.yml include list.
+
+    Args:
+        template_file: Path to template.yml file.
+    """
+    if not template_file.exists():
         logger.debug("No template.yml present in .rhiza; skipping include update")
+        return
+
+    template = RhizaTemplate.from_yaml(template_file)
+    template_include = template.include or []
+    if ".rhiza" not in template_include:
+        logger.warning("The .rhiza folder is not included in your template.yml")
+        template_include.append(".rhiza")
+        logger.info("The .rhiza folder is added to your template.yml to ensure it's included in your repository")
+        template.include = template_include
+        template.to_yaml(template_file)
+
+
+def _migrate_history_file(target: Path, rhiza_dir: Path) -> list[str]:
+    """Migrate .rhiza.history to .rhiza/history.
 
-    # Migrate .rhiza.history to .rhiza/history if it exists
+    Args:
+        target: Target repository path.
+        rhiza_dir: Path to .rhiza directory.
+
+    Returns:
+        List of migrations performed.
+    """
     old_history_file = target / ".rhiza.history"
     new_history_file = rhiza_dir / "history"
+    migrations_performed = []
 
     if old_history_file.exists():
         if new_history_file.exists():
@@ -112,8 +120,6 @@ def migrate(target: Path) -> None:
         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")
@@ -123,7 +129,15 @@ def migrate(target: Path) -> None:
         else:
             logger.debug("No existing .rhiza.history file to migrate")
 
-    # Summary
+    return migrations_performed
+
+
+def _print_migration_summary(migrations_performed: list[str]) -> None:
+    """Print migration summary.
+
+    Args:
+        migrations_performed: List of migrations performed.
+    """
     logger.success("✓ Migration completed successfully")
 
     if migrations_performed:
@@ -145,3 +159,42 @@ def migrate(target: Path) -> None:
         "       git add .\n"
         '       git commit -m "chore: migrate to .rhiza folder structure"\n'
     )
+
+
+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.
+    """
+    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 = _create_rhiza_directory(target)
+
+    # Migrate template file
+    template_exists, template_migrations = _migrate_template_file(target, rhiza_dir)
+
+    # Ensure .rhiza is in include list
+    if template_exists:
+        _ensure_rhiza_in_include(rhiza_dir / "template.yml")
+
+    # Migrate history file
+    history_migrations = _migrate_history_file(target, rhiza_dir)
+
+    # Print summary
+    all_migrations = template_migrations + history_migrations
+    _print_migration_summary(all_migrations)

rhiza/commands/uninstall.py

@@ -11,70 +11,69 @@ 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.
+def _read_history_file(history_file: Path, target: Path) -> list[Path]:
+    """Read history file and return list of files to remove.
 
     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"
+        history_file: Path to history file.
+        target: Target repository path.
 
-    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
+    Returns:
+        List of file paths to remove.
+    """
     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
+    return files_to_remove
 
-    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
+def _confirm_uninstall(files_to_remove: list[Path], target: Path) -> bool:
+    """Show confirmation prompt and get user response.
 
-    # Remove files
+    Args:
+        files_to_remove: List of files to remove.
+        target: Target repository path.
+
+    Returns:
+        True if user confirmed, False otherwise.
+    """
+    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)")
+
+    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 False
+    except (KeyboardInterrupt, EOFError):
+        logger.info("\nUninstall cancelled by user")
+        return False
+
+    return True
+
+
+def _remove_files(files_to_remove: list[Path], target: Path) -> tuple[int, int, int]:
+    """Remove files from repository.
+
+    Args:
+        files_to_remove: List of files to remove.
+        target: Target repository path.
+
+    Returns:
+        Tuple of (removed_count, skipped_count, error_count).
+    """
     logger.info("Removing files...")
     removed_count = 0
     skipped_count = 0
@@ -96,18 +95,28 @@ def uninstall(target: Path, force: bool) -> None:
             logger.error(f"Failed to delete {file_path}: {e}")
             error_count += 1
 
-    # Clean up empty directories
+    return removed_count, skipped_count, error_count
+
+
+def _cleanup_empty_directories(files_to_remove: list[Path], target: Path) -> int:
+    """Clean up empty directories after file removal.
+
+    Args:
+        files_to_remove: List of files that were removed.
+        target: Target repository path.
+
+    Returns:
+        Number of empty directories removed.
+    """
     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)")
@@ -116,19 +125,39 @@ def uninstall(target: Path, force: bool) -> None:
                 else:
                     break
             except Exception:
-                # Directory not empty or other error, stop walking up
                 break
 
-    # Remove history file itself
+    return empty_dirs_removed
+
+
+def _remove_history_file(history_file: Path, target: Path) -> tuple[int, int]:
+    """Remove the history file itself.
+
+    Args:
+        history_file: Path to history file.
+        target: Target repository path.
+
+    Returns:
+        Tuple of (removed_count, error_count).
+    """
     try:
         history_file.unlink()
         logger.success(f"[DEL] {history_file.relative_to(target)}")
-        removed_count += 1
+        return 1, 0
     except Exception as e:
         logger.error(f"Failed to delete {history_file.relative_to(target)}: {e}")
-        error_count += 1
+        return 0, 1
+
+
+def _print_summary(removed_count: int, skipped_count: int, empty_dirs_removed: int, error_count: int) -> None:
+    """Print uninstall summary.
 
-    # Summary
+    Args:
+        removed_count: Number of files removed.
+        skipped_count: Number of files skipped.
+        empty_dirs_removed: Number of empty directories removed.
+        error_count: Number of errors encountered.
+    """
     logger.info("\nUninstall summary:")
     logger.info(f"  Files removed: {removed_count}")
     if skipped_count > 0:
@@ -139,6 +168,56 @@ def uninstall(target: Path, force: bool) -> None:
         logger.error(f"  Errors encountered: {error_count}")
         sys.exit(1)
 
+
+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.
+    """
+    target = target.resolve()
+    logger.info(f"Target repository: {target}")
+
+    # Check for history file
+    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 history file
+    files_to_remove = _read_history_file(history_file, target)
+    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")
+
+    # Confirm uninstall unless force is used
+    if not force:
+        if not _confirm_uninstall(files_to_remove, target):
+            return
+
+    # Remove files
+    removed_count, skipped_count, error_count = _remove_files(files_to_remove, target)
+
+    # Clean up empty directories
+    empty_dirs_removed = _cleanup_empty_directories(files_to_remove, target)
+
+    # Remove history file
+    history_removed, history_error = _remove_history_file(history_file, target)
+    removed_count += history_removed
+    error_count += history_error
+
+    # Print summary
+    _print_summary(removed_count, skipped_count, empty_dirs_removed, error_count)
+
     logger.success("Rhiza templates uninstalled successfully")
     logger.info(
         "Next steps:\n"