roadmap-cli 0.1.1__py3-none-any.whl

roadmap/core/services/issue/issue_creation_service.py

@@ -0,0 +1,309 @@
+"""Service for issue creation operations.
+
+Consolidates business logic for creating issues, including assignee resolution,
+Git branch creation, and formatted display of created issues.
+"""
+
+import os
+import subprocess
+from typing import Any
+
+import click
+import structlog
+
+from roadmap.common.console import get_console
+
+logger = structlog.get_logger()
+
+
+class IssueCreationService:
+    """Service for creating issues with all supporting operations."""
+
+    def __init__(self, core):
+        """Initialize service with core instance.
+
+        Args:
+            core: RoadmapCore instance
+        """
+        self.core = core
+        self._console = get_console()
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Assignee Resolution
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def resolve_and_validate_assignee(
+        self, assignee: str | None = None, auto_detect: bool = True
+    ) -> str | None:
+        """Resolve and validate an assignee.
+
+        Auto-detects from Git if not provided. Validates against team members
+        and returns canonical name.
+
+        Args:
+            assignee: Assignee name to resolve (optional)
+            auto_detect: Whether to auto-detect from Git if not provided
+
+        Returns:
+            Canonical assignee name or None if not assigned
+
+        Raises:
+            click.Abort: If assignee validation fails
+        """
+        # Track whether assignee was explicitly provided (for validation logic)
+        explicitly_provided = assignee is not None
+
+        # Auto-detect from Git if not provided
+        if not assignee and auto_detect:
+            git_user = self.core.git.get_current_user()
+            if git_user:
+                self._console.print(
+                    f"🔍 Auto-detected assignee from Git: {git_user}", style="dim"
+                )
+                assignee = git_user
+
+        if not assignee:
+            return None
+
+        # Only validate if explicitly provided (not auto-detected)
+        if explicitly_provided:
+            is_valid, result = self.core.team.validate_assignee(assignee)
+            if not is_valid:
+                self._console.print(f"[ERROR] Invalid assignee: {result}")
+                raise click.Abort()
+
+            if result and "Warning:" in result:
+                self._console.print(f"⚠️  {result}", style="bold yellow")
+                return assignee
+
+            # Get canonical name
+            canonical = self.core.team.get_canonical_assignee(assignee)
+            if canonical != assignee:
+                self._console.print(
+                    f"🔄 Resolved '{assignee}' to '{canonical}'", style="dim"
+                )
+
+            return canonical
+        else:
+            # Auto-detected assignee - use as-is without validation
+            return assignee
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Git Branch Creation
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def create_branch_for_issue(
+        self,
+        issue,
+        branch_name: str | None = None,
+        checkout: bool = True,
+        force: bool = False,
+    ) -> tuple[bool, str | None]:
+        """Create a Git branch for an issue.
+
+        Attempts multiple strategies to create and checkout the branch, with
+        fallbacks for various failure scenarios.
+
+        Args:
+            issue: Issue object to create branch for
+            branch_name: Explicit branch name (optional)
+            checkout: Whether to checkout the branch
+            force: Whether to force override uncommitted changes
+
+        Returns:
+            Tuple of (success: bool, branch_name: Optional[str])
+        """
+        if not hasattr(self.core, "git") or not self.core.git.is_git_repository():
+            self._console.print(
+                "⚠️  Not in a Git repository, skipping branch creation", style="yellow"
+            )
+            return False, None
+
+        # Determine branch name
+        resolved_name = branch_name or self.core.git.suggest_branch_name(issue.id)
+
+        # Try primary method
+        if self._try_safe_create_branch(issue, checkout, force):
+            self._show_branch_success_message(resolved_name, checkout)
+            return True, resolved_name
+
+        # Check for uncommitted changes
+        if self._has_uncommitted_changes():
+            self._console.print(
+                "⚠️  Working tree has uncommitted changes — branch creation skipped. Use --force to override.",
+                style="yellow",
+            )
+            return False, resolved_name
+
+        # Try fallback strategies
+        if self._try_direct_git_command(resolved_name, checkout):
+            return True, resolved_name
+
+        if self._try_subprocess_git(resolved_name, checkout):
+            return True, resolved_name
+
+        # All strategies failed
+        self._console.print(
+            "⚠️  Failed to create or checkout branch. See git for details.",
+            style="yellow",
+        )
+        return False, resolved_name
+
+    def _try_safe_create_branch(self, issue, checkout: bool, force: bool) -> bool:
+        """Try creating branch using core.git method."""
+        try:
+            return self.core.git.create_branch_for_issue(
+                issue, checkout=checkout, force=force
+            )
+        except TypeError:
+            # Try without force parameter
+            try:
+                return self.core.git.create_branch_for_issue(issue, checkout=checkout)
+            except TypeError:
+                # Try with just issue
+                try:
+                    return self.core.git.create_branch_for_issue(issue)
+                except Exception as e:
+                    logger.debug(
+                        "create_branch_fallback_failed",
+                        operation="create_branch_for_issue",
+                        error=str(e),
+                        action="Returning False",
+                    )
+                    return False
+
+    def _has_uncommitted_changes(self) -> bool:
+        """Check if there are uncommitted changes."""
+        try:
+            status_output = (
+                self.core.git._run_git_command(["status", "--porcelain"]) or ""
+            )
+            return bool(status_output.strip())
+        except Exception as e:
+            logger.debug(
+                "git_status_check_failed",
+                operation="check_git_status",
+                error=str(e),
+                action="Assuming no changes",
+            )
+            return False
+
+    def _try_direct_git_command(self, branch_name: str, checkout: bool) -> bool:
+        """Try creating branch using direct git command via core.git."""
+        try:
+            result = self.core.git._run_git_command(["checkout", "-b", branch_name])
+            if result is not None:
+                self._show_branch_success_message(branch_name, checkout)
+                return True
+
+            # Check if branch exists
+            exists = self.core.git._run_git_command(
+                ["rev-parse", "--verify", branch_name]
+            )
+            if exists:
+                self._show_branch_success_message(branch_name, checkout)
+                return True
+        except Exception as e:
+            logger.debug(
+                "direct_git_command_failed",
+                operation="try_direct_git_command",
+                branch=branch_name,
+                error=str(e),
+                action="Falling back to subprocess",
+            )
+        return False
+
+    def _try_subprocess_git(self, branch_name: str, checkout: bool) -> bool:
+        """Try creating branch using subprocess as last resort."""
+        try:
+            cwd = getattr(self.core, "root_path", None) or os.getcwd()
+            subprocess.run(
+                ["git", "checkout", "-b", branch_name],
+                cwd=cwd,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            self._show_branch_success_message(branch_name, checkout)
+            return True
+        except Exception as e:
+            logger.debug(
+                "branch_creation_failed",
+                branch_name=branch_name,
+                error=str(e),
+                action="create_branch",
+            )
+            return False
+
+    def _show_branch_success_message(self, branch_name: str, checkout: bool) -> None:
+        """Display success message for branch creation."""
+        self._console.print(f"🌿 Created Git branch: {branch_name}", style="green")
+        if checkout:
+            self._console.print(f"✅ Checked out branch: {branch_name}", style="green")
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Display Formatting
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def format_created_issue_display(self, issue, milestone: str | None = None) -> None:
+        """Display formatted information about a newly created issue.
+
+        Args:
+            issue: Created issue object
+            milestone: Optional milestone name
+        """
+        self._console.print(f"✅ Created issue: {issue.title}", style="bold green")
+        self._console.print(f"   ID: {issue.id}", style="bold cyan")
+        self._console.print(f"   Type: {issue.issue_type.value.title()}", style="blue")
+        self._console.print(f"   Priority: {issue.priority.value}", style="yellow")
+
+        if milestone:
+            self._console.print(f"   Milestone: {milestone}", style="blue")
+
+        if self._should_show_assignee(issue.assignee):
+            self._console.print(f"   Assignee: {issue.assignee}", style="magenta")
+
+        self._print_estimate_if_present(issue)
+        self._print_dependency_list(
+            issue, field_name="depends_on", label="Depends on", style="orange1"
+        )
+        self._print_dependency_list(
+            issue, field_name="blocks", label="Blocks", style="red1"
+        )
+
+        if hasattr(issue, "filename"):
+            self._console.print(
+                f"   File: .roadmap/issues/{issue.filename}", style="dim"
+            )
+
+    def _should_show_assignee(self, assignee: object) -> bool:
+        """Return True when assignee should be displayed in success output."""
+        if not assignee:
+            return False
+        assignee_text = str(assignee)
+        return "<Mock" not in assignee_text
+
+    def _print_estimate_if_present(self, issue: Any) -> None:
+        """Print estimated effort if issue contains estimate information."""
+        if hasattr(issue, "estimated_hours") and issue.estimated_hours:
+            self._console.print(
+                f"   Estimated: {issue.estimated_time_display}", style="green"
+            )
+
+    def _print_dependency_list(
+        self,
+        issue: Any,
+        *,
+        field_name: str,
+        label: str,
+        style: str,
+    ) -> None:
+        """Print a dependency list field when present and well-formed."""
+        values = getattr(issue, field_name, None)
+        if not values:
+            return
+        try:
+            if isinstance(values, list | tuple):
+                self._console.print(f"   {label}: {', '.join(values)}", style=style)
+        except (TypeError, AttributeError):
+            return

roadmap/core/services/issue/issue_filter_service.py

@@ -0,0 +1,302 @@
+"""Issue filtering service for issue queries and filtering.
+
+Provides utilities for filtering issues based on various criteria and calculating workload.
+"""
+
+from datetime import UTC
+from typing import TYPE_CHECKING
+
+from roadmap.core.domain import Issue, Priority, Status
+
+if TYPE_CHECKING:
+    from roadmap.infrastructure.coordination.core import RoadmapCore  # noqa: F401
+
+
+class IssueFilterValidator:
+    """Validates filter combinations for issue queries."""
+
+    @staticmethod
+    def validate_filters(
+        assignee: str | None,
+        my_issues: bool,
+        backlog: bool,
+        unassigned: bool,
+        next_milestone: bool,
+        milestone: str | None,
+    ) -> tuple[bool, str | None]:
+        """Validate that filter combinations are valid.
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        # Check for conflicting assignee filters
+        assignee_filters = [assignee is not None, my_issues]
+        if sum(bool(f) for f in assignee_filters) > 1:
+            return False, "Cannot combine --assignee and --my-issues filters"
+
+        # Check for conflicting milestone filters
+        exclusive_filters = [backlog, unassigned, next_milestone, milestone is not None]
+        if sum(bool(f) for f in exclusive_filters) > 1:
+            return (
+                False,
+                "Cannot combine --backlog, --unassigned, --next-milestone, and --milestone filters",
+            )
+
+        return True, None
+
+
+class IssueQueryService:
+    """Service for querying issues with different filter criteria."""
+
+    def __init__(self, core: "RoadmapCore"):  # noqa: F821
+        """Initialize IssueQueryService.
+
+        Args:
+            core: Core roadmap instance.
+        """
+        self.core = core
+
+    def _get_issues_for_assignee_filters(
+        self, my_issues: bool, assignee: str | None
+    ) -> tuple[list[Issue], str] | None:
+        """Get issues for assignee-based filters. Returns None if no match."""
+        if my_issues:
+            return self.core.team.get_my_issues(), "my"
+        if assignee:
+            return self.core.team.get_assigned_issues(
+                assignee
+            ), f"assigned to {assignee}"
+        return None
+
+    def _get_issues_for_collection_filters(
+        self,
+        backlog: bool,
+        unassigned: bool,
+        next_milestone: bool,
+        milestone: str | None,
+    ) -> tuple[list[Issue], str] | None:
+        """Get issues for collection-based filters. Returns None if no match."""
+        if backlog or unassigned:
+            return self.core.issues.get_backlog(), "backlog"
+
+        if next_milestone:
+            next_ms = self.core.milestones.get_next()
+            if not next_ms:
+                return [], ""  # Handled by caller
+            return (
+                self.core.issues.get_by_milestone(next_ms.name),
+                f"next milestone ({next_ms.name})",
+            )
+
+        if milestone:
+            return (
+                self.core.issues.get_by_milestone(milestone),
+                f"milestone '{milestone}'",
+            )
+        return None
+
+    def _get_overdue_issues(self) -> tuple[list[Issue], str]:
+        """Get overdue issues."""
+        from datetime import datetime
+
+        all_issues = self.core.issues.list()
+        now = datetime.now(UTC)
+        overdue_issues: list[Issue] = []
+        for issue in all_issues:
+            if not issue.due_date:
+                continue
+
+            due = issue.due_date
+            if isinstance(due, datetime):
+                if due.tzinfo:
+                    due_aware = due.astimezone(UTC)
+                else:
+                    due_aware = due.replace(tzinfo=UTC)
+            else:
+                due_aware = datetime.fromisoformat(str(due)).replace(tzinfo=UTC)
+
+            if due_aware < now:
+                overdue_issues.append(issue)
+
+        return overdue_issues, "overdue"
+
+    def get_filtered_issues(
+        self,
+        milestone: str | None = None,
+        backlog: bool = False,
+        unassigned: bool = False,
+        next_milestone: bool = False,
+        assignee: str | None = None,
+        my_issues: bool = False,
+        overdue: bool = False,
+    ) -> tuple[list[Issue], str]:
+        """Get issues based on primary filter criteria.
+
+        Returns:
+            Tuple of (issues, filter_description)
+        """
+        # Try assignee filters first
+        result = self._get_issues_for_assignee_filters(my_issues, assignee)
+        if result is not None:
+            return result
+
+        # Try collection filters
+        result = self._get_issues_for_collection_filters(
+            backlog, unassigned, next_milestone, milestone
+        )
+        if result is not None:
+            return result
+
+        # Handle overdue filter
+        if overdue:
+            return self._get_overdue_issues()
+
+        # Show all issues
+        return self.core.issues.list(), "all"
+
+    def apply_additional_filters(
+        self,
+        issues: list[Issue],
+        filter_description: str,
+        open_only: bool = False,
+        blocked_only: bool = False,
+        status: str | None = None,
+        priority: str | None = None,
+        issue_type: str | None = None,
+        overdue: bool = False,
+    ) -> tuple[list[Issue], str]:
+        """Apply additional filters to issue list.
+
+        Returns:
+            Tuple of (filtered_issues, updated_description)
+        """
+        result = issues
+        description = filter_description
+
+        # Apply each filter in sequence
+        if open_only:
+            result, description = self._filter_by_open_status(result, description)
+
+        if blocked_only:
+            result, description = self._filter_by_blocked_status(result, description)
+
+        if status:
+            result, description = self._filter_by_status(result, description, status)
+
+        if priority:
+            result, description = self._filter_by_priority(
+                result, description, priority
+            )
+
+        if issue_type:
+            result, description = self._filter_by_type(result, description, issue_type)
+
+        if overdue:
+            result, description = self._filter_by_overdue(result, description)
+
+        return result, description
+
+    @staticmethod
+    def _filter_by_open_status(
+        issues: list[Issue], description: str
+    ) -> tuple[list[Issue], str]:
+        """Filter to only open issues (not closed)."""
+        filtered = [i for i in issues if i.status != Status.CLOSED]
+        return filtered, description + " open"
+
+    @staticmethod
+    def _filter_by_blocked_status(
+        issues: list[Issue], description: str
+    ) -> tuple[list[Issue], str]:
+        """Filter to only blocked issues."""
+        filtered = [i for i in issues if i.status == Status.BLOCKED]
+        return filtered, description + " blocked"
+
+    @staticmethod
+    def _filter_by_status(
+        issues: list[Issue], description: str, status: str
+    ) -> tuple[list[Issue], str]:
+        """Filter by specific status."""
+        filtered = [i for i in issues if i.status == Status(status)]
+        return filtered, description + f" {status}"
+
+    @staticmethod
+    def _filter_by_priority(
+        issues: list[Issue], description: str, priority: str
+    ) -> tuple[list[Issue], str]:
+        """Filter by priority level."""
+        filtered = [i for i in issues if i.priority == Priority(priority)]
+        return filtered, description + f" {priority} priority"
+
+    @staticmethod
+    def _filter_by_type(
+        issues: list[Issue], description: str, issue_type: str
+    ) -> tuple[list[Issue], str]:
+        """Filter by issue type."""
+        from roadmap.core.domain import IssueType
+
+        filtered = [i for i in issues if i.issue_type == IssueType(issue_type)]
+        return filtered, description + f" {issue_type}"
+
+    @staticmethod
+    def _filter_by_overdue(
+        issues: list[Issue], description: str
+    ) -> tuple[list[Issue], str]:
+        """Filter to only overdue issues."""
+        from datetime import datetime
+
+        now = datetime.now(UTC)
+        filtered: list[Issue] = []
+        for i in issues:
+            if not i.due_date:
+                continue
+
+            due = i.due_date
+            if isinstance(due, datetime):
+                if due.tzinfo:
+                    due_aware = due.astimezone(UTC)
+                else:
+                    due_aware = due.replace(tzinfo=UTC)
+            else:
+                due_aware = datetime.fromisoformat(str(due)).replace(tzinfo=UTC)
+
+            if due_aware < now:
+                filtered.append(i)
+
+        return filtered, description + " overdue"
+
+
+class WorkloadCalculator:
+    """Calculates time estimates and workload breakdowns."""
+
+    @staticmethod
+    def calculate_workload(issues: list[Issue]) -> dict:
+        """Calculate workload statistics for a list of issues.
+
+        Returns:
+            Dictionary with total_hours, status_breakdown
+        """
+        total_hours = sum(issue.estimated_hours or 0 for issue in issues)
+
+        status_counts = {}
+        for issue in issues:
+            status = issue.status.value
+            if status not in status_counts:
+                status_counts[status] = {"count": 0, "hours": 0}
+            status_counts[status]["count"] += 1
+            status_counts[status]["hours"] += issue.estimated_hours or 0
+
+        return {
+            "total_hours": total_hours,
+            "status_breakdown": status_counts,
+        }
+
+    @staticmethod
+    def format_time_display(hours: float) -> str:
+        """Format time in hours to human-readable display."""
+        if hours < 1:
+            return f"{hours * 60:.0f}m"
+        elif hours <= 24:
+            return f"{hours:.1f}h"
+        else:
+            return f"{hours / 8:.1f}d"