roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/crud/base_delete.py

@@ -0,0 +1,155 @@
+"""Base class for delete operations across all entity types."""
+
+from abc import ABC
+from typing import Any
+
+import click
+
+from roadmap.adapters.cli.crud.crud_helpers import EntityType
+from roadmap.adapters.cli.crud.crud_utils import (
+    delete_entity_by_type,
+    format_entity_not_found_error,
+    get_entity_by_type,
+    get_entity_title,
+)
+from roadmap.adapters.cli.presentation.crud_presenter import DeletePresenter
+from roadmap.common.console import get_console
+
+
+class BaseDelete(ABC):
+    """Abstract base class for entity delete commands.
+
+    Subclasses implement:
+    - entity_type: The EntityType this deletes
+
+    Uses Template Method pattern for extensibility.
+    """
+
+    entity_type: EntityType
+
+    def __init__(self, core: Any, console: Any = None) -> None:
+        """Initialize delete command.
+
+        Args:
+            core: The core application context
+            console: Optional console for output (uses default if not provided)
+        """
+        self.core = core
+        self.console = console or get_console()
+
+    def post_delete_hook(self, entity_id: str, **kwargs) -> None:  # noqa: B027
+        """Handle entity deletion completion with optional custom logic.
+
+        Override to handle cleanup, notifications, etc.
+
+        Args:
+            entity_id: ID of deleted entity
+            **kwargs: Original CLI arguments
+        """
+        pass
+
+    def execute(self, entity_id: str, force: bool = False, **kwargs) -> bool:
+        """Execute the delete operation.
+
+        Args:
+            entity_id: ID of entity to delete
+            force: Whether to force deletion without confirmation
+            **kwargs: All other CLI arguments
+
+        Returns:
+            True if deletion succeeded, False otherwise
+        """
+        try:
+            # Verify entity exists
+            entity = self._get_entity(entity_id)
+            if entity is None:
+                self.console.print(
+                    format_entity_not_found_error(self.entity_type, entity_id),
+                    style="red",
+                )
+                return False
+
+            # Request confirmation if not forced
+            if not force:
+                title = self._get_title(entity)
+                if not click.confirm(
+                    f"Delete {self.entity_type.value} '{title}'? This cannot be undone."
+                ):
+                    self.console.print("⚠️  Delete cancelled", style="yellow")
+                    return False
+
+            # Delete via appropriate service
+            if not self._delete_entity(entity_id):
+                return False
+
+            # Run post-delete hooks
+            self.post_delete_hook(entity_id, **kwargs)
+
+            # Display success
+            self._display_success(entity_id, entity)
+
+            return True
+
+        except Exception as e:
+            self.console.print(
+                f"❌ Failed to delete {self.entity_type.value}: {str(e)}",
+                style="red",
+            )
+            raise click.ClickException(str(e)) from e
+
+    def _get_entity(self, entity_id: str) -> Any | None:
+        """Get entity by ID.
+
+        Args:
+            entity_id: Entity ID to retrieve
+
+        Returns:
+            Entity object or None if not found
+        """
+        return get_entity_by_type(self.core, self.entity_type, entity_id)
+
+    def _delete_entity(self, entity_id: str) -> bool:
+        """Delete entity via appropriate service.
+
+        Args:
+            entity_id: Entity ID to delete
+
+        Returns:
+            True if deletion succeeded
+        """
+        try:
+            delete_entity_by_type(self.core, self.entity_type, entity_id)
+            return True
+        except Exception as e:
+            from roadmap.common.logging import get_logger
+
+            logger = get_logger(__name__)
+            logger.debug(
+                "entity_deletion_failed",
+                entity_id=entity_id,
+                entity_type=self.entity_type,
+                error=str(e),
+                action="delete_entity",
+            )
+            return False
+
+    def _display_success(self, entity_id: str, entity: Any) -> None:
+        """Display success message.
+
+        Args:
+            entity_id: ID of deleted entity
+            entity: The deleted entity
+        """
+        presenter = DeletePresenter()
+        presenter.render(entity)
+
+    def _get_title(self, entity: Any) -> str:
+        """Get entity title/name.
+
+        Args:
+            entity: The entity object
+
+        Returns:
+            Title or name string
+        """
+        return get_entity_title(entity)

roadmap/adapters/cli/crud/base_restore.py

@@ -0,0 +1,283 @@
+"""Base class for restore operations across all entity types."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+import click
+
+from roadmap.adapters.cli.crud.crud_helpers import (
+    EntityType,
+    display_restore_success,
+    get_active_dir,
+    get_archive_dir,
+)
+from roadmap.common.console import get_console
+
+
+class BaseRestore(ABC):
+    """Abstract base class for entity restore commands using Template Method pattern.
+
+    Subclasses must implement:
+    - entity_type: The EntityType this restores
+    - get_archived_files_to_restore(): Determine which archived files to restore
+    - post_restore_hook(): Update database and handle entity-specific logic
+
+    Subclasses may override:
+    - validate_entity_before_restore(): Custom validation before restoring
+    - check_conflict(): Custom conflict detection logic
+
+    This class handles the overall restore workflow:
+    1. Find archived files matching criteria
+    2. Validate before restoring
+    3. Check for conflicts with active entities
+    4. Move files from archive to active
+    5. Update state via post_restore_hook
+    6. Display results
+    """
+
+    entity_type: EntityType
+
+    def __init__(self, core: Any, console: Any = None) -> None:
+        """Initialize restore command.
+
+        Args:
+            core: The core application context
+            console: Optional console for output (uses default if not provided)
+        """
+        self.core = core
+        self.console = console or get_console()
+
+    @abstractmethod
+    def get_archived_files_to_restore(
+        self, entity_id: str | None = None, **filters
+    ) -> list[Path]:
+        """Determine which archived files should be restored.
+
+        Args:
+            entity_id: Optional specific entity ID to restore
+            **filters: Entity-specific filter criteria
+
+        Returns:
+            List of archived file paths to restore
+        """
+
+    @abstractmethod
+    def post_restore_hook(self, restored_files: list[Path], **kwargs) -> None:
+        """Handle entity-specific state updates after restoring.
+
+        Override to update database, send notifications, etc.
+
+        Args:
+            restored_files: List of files that were restored
+            **kwargs: Original CLI arguments
+        """
+
+    def validate_entity_before_restore(
+        self, file_path: Path
+    ) -> tuple[bool, str | None]:
+        """Validate entity before restoring.
+
+        Allows subclasses to add entity-specific validation rules.
+
+        Args:
+            file_path: The file being considered for restore
+
+        Returns:
+            Tuple of (is_valid, error_message_or_none)
+        """
+        return True, None
+
+    def check_conflict(self, archived_file: Path) -> tuple[bool, str | None]:
+        """Check if restoring would cause a conflict.
+
+        Override for custom conflict detection.
+
+        Args:
+            archived_file: The file being restored
+
+        Returns:
+            Tuple of (has_conflict, conflict_description)
+        """
+        active_dir = get_active_dir(self.entity_type)
+        active_file = active_dir / archived_file.name
+        if active_file.exists():
+            return True, f"already exists in active {self.entity_type.value}s"
+        return False, None
+
+    def _validate_files_for_restore(
+        self, files_to_restore: list[Path]
+    ) -> tuple[list[Path], list[tuple[Path, str | None]]]:
+        """Validate files before restoration.
+
+        Args:
+            files_to_restore: List of files to validate
+
+        Returns:
+            Tuple of (valid_files, invalid_files_with_reasons)
+        """
+        invalid_files = []
+
+        for file_path in files_to_restore:
+            is_valid, error_msg = self.validate_entity_before_restore(file_path)
+            if not is_valid:
+                invalid_files.append((file_path, error_msg))
+
+        valid_files = [
+            f for f in files_to_restore if f not in [f[0] for f in invalid_files]
+        ]
+
+        return valid_files, invalid_files
+
+    def _check_files_for_conflicts(
+        self, files_to_restore: list[Path]
+    ) -> tuple[list[Path], list[tuple[Path, str | None]]]:
+        """Check files for conflicts with active entities.
+
+        Args:
+            files_to_restore: List of files to check
+
+        Returns:
+            Tuple of (non_conflicting_files, conflicting_files_with_reasons)
+        """
+        conflicts = []
+
+        for file_path in files_to_restore:
+            has_conflict, conflict_desc = self.check_conflict(file_path)
+            if has_conflict:
+                conflicts.append((file_path, conflict_desc))
+
+        non_conflicting = [
+            f for f in files_to_restore if f not in [f[0] for f in conflicts]
+        ]
+
+        return non_conflicting, conflicts
+
+    def _perform_file_restore(
+        self, files_to_restore: list[Path]
+    ) -> tuple[list[Path], int]:
+        """Move files from archive to active directory.
+
+        Args:
+            files_to_restore: List of files to restore
+
+        Returns:
+            Tuple of (successfully_restored_files, failed_count)
+        """
+        active_dir = get_active_dir(self.entity_type)
+        active_dir.mkdir(parents=True, exist_ok=True)
+
+        restored_files = []
+        failed_count = 0
+
+        for archive_file in files_to_restore:
+            try:
+                active_file = active_dir / archive_file.name
+                active_file.write_text(archive_file.read_text())
+                archive_file.unlink()
+                restored_files.append(active_file)
+            except Exception as e:
+                self.console.print(
+                    f"⚠️  Failed to restore {archive_file.name}: {str(e)}",
+                    style="yellow",
+                )
+                failed_count += 1
+
+        return restored_files, failed_count
+
+    def _display_validation_errors(
+        self, invalid_files: list[tuple[Path, str | None]]
+    ) -> None:
+        """Display validation errors to user.
+
+        Args:
+            invalid_files: List of files with validation errors
+        """
+        for file_path, error_msg in invalid_files:
+            self.console.print(
+                f"⚠️  Cannot restore {file_path.name}: {error_msg}",
+                style="yellow",
+            )
+
+    def _display_conflicts(self, conflicts: list[tuple[Path, str | None]]) -> None:
+        """Display conflict errors to user.
+
+        Args:
+            conflicts: List of conflicting files
+        """
+        for file_path, conflict_desc in conflicts:
+            self.console.print(
+                f"⚠️  Cannot restore {file_path.name}: {conflict_desc}",
+                style="yellow",
+            )
+
+    def execute(self, entity_id: str | None = None, **kwargs) -> bool:
+        """Execute restore operation (Template Method).
+
+        Args:
+            entity_id: Optional specific entity ID to restore
+            **kwargs: Entity-specific filters and options
+
+        Returns:
+            True if restore succeeded
+        """
+        try:
+            # Step 1: Find archived files matching criteria
+            archive_dir = get_archive_dir(self.entity_type)
+
+            if not archive_dir.exists():
+                self.console.print(
+                    f"No archive found for {self.entity_type.value}s",
+                    style="yellow",
+                )
+                return False
+
+            files_to_restore = self.get_archived_files_to_restore(entity_id, **kwargs)
+
+            if not files_to_restore:
+                self.console.print(
+                    f"No archived {self.entity_type.value}s found to restore",
+                    style="yellow",
+                )
+                return False
+
+            # Step 2: Validate files
+            files_to_restore, invalid_files = self._validate_files_for_restore(
+                files_to_restore
+            )
+            if invalid_files:
+                self._display_validation_errors(invalid_files)
+                if not files_to_restore:
+                    return False
+
+            # Step 3: Check for conflicts
+            files_to_restore, conflicts = self._check_files_for_conflicts(
+                files_to_restore
+            )
+            if conflicts:
+                self._display_conflicts(conflicts)
+                if not files_to_restore:
+                    return False
+
+            # Step 4: Restore files
+            restored_files, failed_count = self._perform_file_restore(files_to_restore)
+
+            # Step 5: Update state via hook
+            self.post_restore_hook(restored_files, **kwargs)
+
+            # Step 6: Display results
+            display_restore_success(
+                self.entity_type,
+                len(restored_files),
+                failed_count,
+                console=self.console,
+            )
+
+            return True
+
+        except Exception as e:
+            self.console.print(
+                f"❌ Restore operation failed: {str(e)}",
+                style="red",
+            )
+            raise click.ClickException(str(e)) from e

roadmap/adapters/cli/crud/base_update.py

@@ -0,0 +1,193 @@
+"""Base class for update operations across all entity types."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+import click
+
+from roadmap.adapters.cli.crud.crud_helpers import EntityType
+from roadmap.adapters.cli.crud.crud_utils import (
+    format_entity_not_found_error,
+    get_entity_by_type,
+    get_entity_id,
+    get_entity_title,
+    update_entity_by_type,
+)
+from roadmap.adapters.cli.presentation.crud_presenter import UpdatePresenter
+from roadmap.common.console import get_console
+from roadmap.common.errors.exceptions import ValidationError
+from roadmap.common.logging import log_audit_event
+
+
+class BaseUpdate(ABC):
+    """Abstract base class for entity update commands.
+
+    Subclasses implement:
+    - entity_type: The EntityType this updates
+    - build_update_dict(): Convert CLI args to update dict
+    - post_update_hook(): Optional hook after update (default: no-op)
+
+    Uses Template Method pattern for extensibility.
+    """
+
+    entity_type: EntityType
+
+    def __init__(self, core: Any, console: Any = None) -> None:
+        """Initialize update command.
+
+        Args:
+            core: The core application context
+            console: Optional console for output (uses default if not provided)
+        """
+        self.core = core
+        self.console = console or get_console()
+
+    @abstractmethod
+    def build_update_dict(self, entity_id: str, **kwargs) -> dict[str, Any]:
+        """Convert CLI arguments to update dictionary.
+
+        Args:
+            entity_id: ID of entity to update
+            **kwargs: All click option values
+
+        Returns:
+            Dictionary of fields to update
+
+        Raises:
+            ValidationError: If arguments are invalid
+        """
+        ...
+
+    def post_update_hook(  # noqa: B027
+        self, entity: Any, update_dict: dict[str, Any], **kwargs
+    ) -> None:
+        """Handle entity update completion with optional custom logic.
+
+        Override to handle:
+        - Git branch updates
+        - Milestone reassignments
+        - Custom notifications
+
+        Args:
+            entity: The updated entity
+            update_dict: The update dict that was applied
+            **kwargs: Original CLI arguments
+        """
+        ...
+
+    def execute(self, entity_id: str, **kwargs) -> Any | None:
+        """Execute the update operation.
+
+        Args:
+            entity_id: ID of entity to update
+            **kwargs: All other CLI arguments
+
+        Returns:
+            Updated entity, or None if update failed
+        """
+        try:
+            # Verify entity exists
+            entity = self._get_entity(entity_id)
+            if entity is None:
+                self.console.print(
+                    format_entity_not_found_error(self.entity_type, entity_id),
+                    style="red",
+                )
+                raise click.ClickException(f"{self.entity_type.value} not found")
+
+            # Build update dict from arguments
+            update_dict = self.build_update_dict(entity_id=entity_id, **kwargs)
+
+            # Update via appropriate service
+            updated_entity = self._update_entity(entity_id, update_dict)
+            if updated_entity is None:
+                return None
+
+            # Run post-update hooks
+            self.post_update_hook(updated_entity, update_dict, **kwargs)
+
+            # Log audit event for successful update
+            entity_id = self._get_id(updated_entity)
+            log_audit_event(
+                action="update",
+                entity_type=self.entity_type.value,
+                entity_id=entity_id,
+                before={"entity_id": entity_id},  # Original only tracked by entity_id
+                after=update_dict,
+            )
+
+            # Display success
+            self._display_success(updated_entity)
+
+            return updated_entity
+
+        except ValidationError:
+            # ValidationError will be handled by centralized CLI exception handler
+            # which formats it and directs to stderr
+            raise
+        except Exception:
+            # Other exceptions will also be handled by centralized handler
+            raise
+
+    def _get_entity(self, entity_id: str) -> Any | None:
+        """Get entity by ID.
+
+        Args:
+            entity_id: Entity ID to retrieve
+
+        Returns:
+            Entity object or None if not found
+        """
+        return get_entity_by_type(self.core, self.entity_type, entity_id)
+
+    def _update_entity(self, entity_id: str, update_dict: dict[str, Any]) -> Any | None:
+        """Update entity via appropriate service.
+
+        Args:
+            entity_id: Entity ID to update
+            update_dict: Dictionary of fields to update
+
+        Returns:
+            Updated entity or None if failed
+        """
+        result = update_entity_by_type(
+            self.core, self.entity_type, entity_id, update_dict
+        )
+
+        # Some coordinator update methods (e.g., milestones) return bool instead
+        # of the updated entity. Normalize by fetching the entity after success.
+        if isinstance(result, bool):
+            return self._get_entity(entity_id) if result else None
+
+        return result
+
+    def _display_success(self, entity: Any) -> None:
+        """Display success message.
+
+        Args:
+            entity: The updated entity
+        """
+        presenter = UpdatePresenter()
+        presenter.render(entity)
+
+    def _get_title(self, entity: Any) -> str:
+        """Get entity title/name.
+
+        Args:
+            entity: The entity object
+
+        Returns:
+            Title or name string
+        """
+        return get_entity_title(entity)
+
+    def _get_id(self, entity: Any) -> str:
+        """Get entity ID.
+
+        Args:
+            entity: The entity object
+
+        Returns:
+            Entity ID string
+        """
+        return get_entity_id(entity)