roadmap-cli 0.1.1__py3-none-any.whl

roadmap/common/errors/error_git.py

@@ -0,0 +1,67 @@
+"""Git operation related error classes."""
+
+from roadmap.common.errors.error_base import ErrorCategory, ErrorSeverity, RoadmapError
+
+
+class GitOperationError(RoadmapError):
+    """Errors related to Git operations."""
+
+    def __init__(
+        self,
+        message: str,
+        command: str | None = None,
+        exit_code: int | None = None,
+        **kwargs,
+    ):
+        """Initialize GitOperationError.
+
+        Args:
+            message: Error message.
+            command: Git command that failed.
+            exit_code: Exit code from the Git command.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        context = kwargs.get("context", {})
+        if command:
+            context["command"] = command
+        if exit_code is not None:
+            context["exit_code"] = exit_code
+
+        super().__init__(
+            message,
+            severity=kwargs.get("severity", ErrorSeverity.HIGH),
+            category=ErrorCategory.GIT_OPERATION,
+            context=context,
+            cause=kwargs.get("cause"),
+        )
+        self.command = command
+        self.exit_code = exit_code
+
+
+class ConfigurationError(RoadmapError):
+    """Errors related to configuration."""
+
+    def __init__(self, message: str, config_file=None, **kwargs):
+        """Initialize ConfigurationError.
+
+        Args:
+            message: Error message.
+            config_file: Path to the configuration file with the issue.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        from pathlib import Path
+
+        context = kwargs.get("context", {})
+        if config_file:
+            context["config_file"] = (
+                str(config_file) if isinstance(config_file, Path) else config_file
+            )
+
+        super().__init__(
+            message,
+            severity=kwargs.get("severity", ErrorSeverity.HIGH),
+            category=ErrorCategory.CONFIGURATION,
+            context=context,
+            cause=kwargs.get("cause"),
+        )
+        self.config_file = config_file

roadmap/common/errors/error_handler.py

@@ -0,0 +1,166 @@
+"""Error handling utilities and context managers."""
+
+import sys
+from contextlib import contextmanager
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from structlog import get_logger
+from structlog.typing import FilteringBoundLogger
+
+from roadmap.common.errors.error_base import ErrorCategory, ErrorSeverity, RoadmapError
+
+logger = get_logger()
+
+
+class ErrorHandler:
+    """Centralized error handling utilities."""
+
+    def __init__(
+        self, logger: FilteringBoundLogger | None = None, console: Console | None = None
+    ):
+        """Initialize ErrorHandler.
+
+        Args:
+            logger: Logger instance for error logging. Defaults to module logger.
+            console: Console instance for error display. Defaults to stderr console.
+        """
+        self.logger = logger or get_logger()
+        self.console = console or Console(stderr=True)
+        self.error_counts: dict[ErrorCategory, int] = {}
+
+    def handle_error(
+        self,
+        error: Exception | RoadmapError,
+        context: dict[str, Any] | None = None,
+        show_traceback: bool = False,
+        exit_on_critical: bool = True,
+    ) -> bool:
+        """Handle an error with consistent logging and display.
+
+        Args:
+            error: The error to handle
+            context: Additional context information
+            show_traceback: Whether to show full traceback
+            exit_on_critical: Whether to exit on critical errors
+
+        Returns:
+            bool: True if error was handled successfully, False if should propagate
+        """
+        # Convert to RoadmapError if needed
+        if not isinstance(error, RoadmapError):
+            error = RoadmapError(
+                str(error),
+                severity=ErrorSeverity.MEDIUM,
+                category=ErrorCategory.VALIDATION,
+                context=context,
+                cause=error,
+            )
+
+        # Update error counts
+        self.error_counts[error.category] = self.error_counts.get(error.category, 0) + 1
+
+        # Log the error
+        self._log_error(error, show_traceback)
+
+        # Display to user
+        self._display_error(error, show_traceback)
+
+        # Handle critical errors
+        if error.severity == ErrorSeverity.CRITICAL and exit_on_critical:
+            sys.exit(1)
+
+        return True
+
+    def _log_error(self, error: RoadmapError, show_traceback: bool = False):
+        """Log error with appropriate level."""
+        log_message = (
+            f"{error.category.value}: {error.message}{error.get_context_info()}"
+        )
+
+        if error.severity in [ErrorSeverity.CRITICAL, ErrorSeverity.HIGH]:
+            self.logger.error(log_message)
+        elif error.severity == ErrorSeverity.MEDIUM:
+            self.logger.warning(log_message)
+        else:
+            self.logger.info(log_message)
+
+        # Log traceback if requested or for critical errors
+        if show_traceback or error.severity == ErrorSeverity.CRITICAL:
+            if error.cause:
+                self.logger.error("Caused by:", exc_info=error.cause)
+            else:
+                self.logger.error("Traceback:", exc_info=True)
+
+    def _display_error(self, error: RoadmapError, show_traceback: bool = False):
+        """Display error to user with rich formatting."""
+        # Choose color based on severity
+        color_map = {
+            ErrorSeverity.CRITICAL: "red",
+            ErrorSeverity.HIGH: "red",
+            ErrorSeverity.MEDIUM: "yellow",
+            ErrorSeverity.LOW: "blue",
+            ErrorSeverity.WARNING: "yellow",
+            ErrorSeverity.INFO: "blue",
+        }
+
+        color = color_map.get(error.severity, "white")
+
+        # Create error message
+        title = f"{error.severity.value.upper()}: {error.category.value.replace('_', ' ').title()}"
+        message = error.message
+
+        if error.context:
+            context_info = error.get_context_info()
+            message += f"\n[dim]{context_info}[/dim]"
+
+        if show_traceback and error.cause:
+            message += f"\n\n[dim]Caused by: {str(error.cause)}[/dim]"
+
+        # Display panel
+        panel = Panel(message, title=title, border_style=color, expand=False)
+
+        self.console.print(panel)
+
+    def get_error_summary(self) -> dict[str, int]:
+        """Get summary of error counts by category."""
+        return {category.value: count for category, count in self.error_counts.items()}
+
+
+@contextmanager
+def handle_errors(
+    error_handler: ErrorHandler | None = None,
+    ignore_errors: bool = False,
+    show_traceback: bool = False,
+    exit_on_critical: bool = True,
+    context: dict[str, Any] | None = None,
+):
+    """Context manager for consistent error handling.
+
+    Args:
+        error_handler: Custom error handler instance
+        ignore_errors: Whether to suppress all errors
+        show_traceback: Whether to show tracebacks
+        exit_on_critical: Whether to exit on critical errors
+        context: Additional context for errors
+    """
+    handler = error_handler or ErrorHandler()
+
+    try:
+        yield handler
+    except RoadmapError as e:
+        if not ignore_errors:
+            handler.handle_error(e, context, show_traceback, exit_on_critical)
+        if not ignore_errors and e.severity == ErrorSeverity.CRITICAL:
+            raise
+    except Exception as e:
+        if not ignore_errors:
+            roadmap_error = RoadmapError(
+                str(e), severity=ErrorSeverity.HIGH, context=context, cause=e
+            )
+            handler.handle_error(
+                roadmap_error, context, show_traceback, exit_on_critical
+            )
+        if not ignore_errors:
+            raise

roadmap/common/errors/error_network.py

@@ -0,0 +1,90 @@
+"""Network and GitHub API related error classes."""
+
+from roadmap.common.errors.error_base import ErrorCategory, ErrorSeverity, RoadmapError
+
+
+class NetworkError(RoadmapError):
+    """Errors related to network operations."""
+
+    def __init__(
+        self,
+        message: str,
+        url: str | None = None,
+        status_code: int | None = None,
+        **kwargs,
+    ):
+        """Initialize NetworkError.
+
+        Args:
+            message: Error message.
+            url: URL where the network error occurred.
+            status_code: HTTP status code from the response.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        context = kwargs.get("context", {})
+        if url:
+            context["url"] = url
+        if status_code:
+            context["status_code"] = status_code
+
+        super().__init__(
+            message,
+            severity=kwargs.get("severity", ErrorSeverity.HIGH),
+            category=ErrorCategory.NETWORK,
+            context=context,
+            cause=kwargs.get("cause"),
+        )
+        self.url = url
+        self.status_code = status_code
+
+
+class GitHubAPIError(NetworkError):
+    """Errors specific to GitHub API operations."""
+
+    def __init__(
+        self,
+        message: str,
+        endpoint: str | None = None,
+        rate_limit_remaining: int | None = None,
+        **kwargs,
+    ):
+        """Initialize GitHubAPIError.
+
+        Args:
+            message: Error message.
+            endpoint: GitHub API endpoint that was called.
+            rate_limit_remaining: Number of remaining GitHub API requests.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        context = kwargs.get("context", {})
+        if endpoint:
+            context["endpoint"] = endpoint
+        if rate_limit_remaining is not None:
+            context["rate_limit_remaining"] = rate_limit_remaining
+
+        super().__init__(
+            message,
+            severity=kwargs.get("severity", ErrorSeverity.HIGH),
+            **kwargs,
+        )
+        self.endpoint = endpoint
+        self.rate_limit_remaining = rate_limit_remaining
+
+
+class AuthenticationError(RoadmapError):
+    """Raised when authentication fails."""
+
+    def __init__(self, message: str, **kwargs):
+        """Initialize AuthenticationError.
+
+        Args:
+            message: Error message.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        super().__init__(
+            message,
+            severity=kwargs.get("severity", ErrorSeverity.HIGH),
+            category=ErrorCategory.PERMISSION,
+            context=kwargs.get("context", {}),
+            cause=kwargs.get("cause"),
+        )

roadmap/common/errors/error_security.py

@@ -0,0 +1,78 @@
+"""Parsing and security related error classes."""
+
+from pathlib import Path
+
+from roadmap.common.errors.error_base import ErrorCategory, ErrorSeverity, RoadmapError
+
+
+class ParseError(RoadmapError):
+    """Raised when parsing fails."""
+
+    def __init__(
+        self,
+        message: str,
+        file_path: Path | None = None,
+        line_number: int | None = None,
+        **kwargs,
+    ):
+        """Initialize ParseError.
+
+        Args:
+            message: Error message.
+            file_path: Path to the file that failed to parse.
+            line_number: Line number where the parse error occurred.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        context = kwargs.get("context", {})
+        if file_path:
+            context["file_path"] = str(file_path)
+        if line_number:
+            context["line_number"] = line_number
+
+        super().__init__(
+            message,
+            severity=kwargs.get("severity", ErrorSeverity.HIGH),
+            category=ErrorCategory.PARSING,
+            context=context,
+            cause=kwargs.get("cause"),
+        )
+        self.file_path = file_path
+        self.line_number = line_number
+
+
+class SecurityError(RoadmapError):
+    """Base class for security-related errors."""
+
+    def __init__(self, message: str, **kwargs):
+        """Initialize SecurityError.
+
+        Args:
+            message: Error message.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        super().__init__(
+            message,
+            severity=kwargs.get("severity", ErrorSeverity.CRITICAL),
+            category=ErrorCategory.PERMISSION,
+            context=kwargs.get("context", {}),
+            cause=kwargs.get("cause"),
+        )
+
+
+class PathValidationError(SecurityError):
+    """Raised when path validation fails (path traversal, etc.)."""
+
+    def __init__(self, message: str, path: Path | str | None = None, **kwargs):
+        """Initialize PathValidationError.
+
+        Args:
+            message: Error message.
+            path: Path that failed validation.
+            **kwargs: Additional arguments passed to parent class.
+        """
+        context = kwargs.get("context", {})
+        if path:
+            context["path"] = str(path)
+
+        super().__init__(message, context=context, **kwargs)
+        self.path = path