roadmap-cli 0.1.1__py3-none-any.whl

roadmap/core/services/issue/issue_update_service.py

@@ -0,0 +1,144 @@
+"""Service for issue update operations.
+
+Consolidates business logic for updating issues, including building update
+dictionaries from CLI parameters, resolving assignees, and displaying results.
+"""
+
+from roadmap.common.console import get_console
+from roadmap.common.errors.exceptions import ValidationError
+from roadmap.common.update_constants import DISPLAYABLE_UPDATE_FIELDS
+from roadmap.core.domain import Priority, Status
+
+
+class IssueUpdateService:
+    """Service for updating 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()
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Update Dictionary Building
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def build_update_dict(
+        self,
+        title: str | None = None,
+        priority: str | None = None,
+        status: str | None = None,
+        assignee: str | None = None,
+        milestone: str | None = None,
+        description: str | None = None,
+        estimate: float | None = None,
+    ) -> dict:
+        """Build update dictionary from provided parameters.
+
+        Validates and normalizes all update fields, resolving assignees and
+        converting enum strings to proper types.
+
+        Args:
+            title: New title (optional)
+            priority: New priority as string (optional)
+            status: New status as string (optional)
+            assignee: New assignee (optional)
+            milestone: New milestone (optional)
+            description: New description (optional)
+            estimate: New estimate in hours (optional)
+
+        Returns:
+            Dictionary of updates ready to apply to an issue
+        """
+        updates = {}
+
+        if title:
+            updates["title"] = title
+        if priority:
+            updates["priority"] = Priority(priority)
+        if status:
+            updates["status"] = Status(status)
+        if assignee is not None:
+            assignee_value = self.resolve_assignee_for_update(assignee)
+            updates["assignee"] = assignee_value
+        if milestone:
+            updates["milestone"] = milestone
+        if description:
+            updates["description"] = description
+        if estimate is not None:
+            updates["estimated_hours"] = estimate
+
+        return updates
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Assignee Resolution for Updates
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def resolve_assignee_for_update(self, assignee: str):
+        """Resolve and validate assignee for update operation.
+
+        Args:
+            assignee: Assignee to resolve
+
+        Returns:
+            - Resolved assignee string
+            - None for unassignment (empty string)
+            - False if validation failed
+        """
+        # Convert empty string to None for proper unassignment
+        if assignee == "":
+            return None
+
+        # Validate assignee
+        is_valid, result = self.core.validate_assignee(assignee)
+        if not is_valid:
+            raise ValidationError(
+                domain_message=f"Assignee validation failed: {result}",
+                user_message=f"Invalid assignee: {result}",
+            )
+        elif result and "Warning:" in result:
+            self._console.print(f"⚠️  {result}", style="bold yellow")
+            return assignee
+        else:
+            canonical_assignee = self.core.team.get_canonical_assignee(assignee)
+            if canonical_assignee != assignee:
+                self._console.print(
+                    f"🔄 Resolved '{assignee}' to '{canonical_assignee}'",
+                    style="dim",
+                )
+            return canonical_assignee
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Display Results
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def display_update_result(
+        self, updated_issue, updates: dict, reason: str | None = None
+    ) -> None:
+        """Display the results of an issue update.
+
+        Args:
+            updated_issue: The updated issue object
+            updates: Dictionary of fields that were updated
+            reason: Optional reason/comment for the update
+        """
+        self._console.print(
+            f"✅ Updated issue: {updated_issue.title}", style="bold green"
+        )
+        self._console.print(f"   ID: {updated_issue.id}", style="cyan")
+
+        # Show what was updated
+        for field, value in updates.items():
+            if field == "estimated_hours":
+                display_value = updated_issue.estimated_time_display
+                self._console.print(f"   estimate: {display_value}", style="cyan")
+            elif field in DISPLAYABLE_UPDATE_FIELDS:
+                # Format enum values to show just the string value
+                display_value = value.value if hasattr(value, "value") else value
+                self._console.print(f"   {field}: {display_value}", style="cyan")
+
+        if reason:
+            self._console.print(f"   reason: {reason}", style="dim")

roadmap/core/services/issue/start_issue_service.py

@@ -0,0 +1,174 @@
+"""Service for starting work on issues.
+
+Consolidates business logic for updating issue status, setting start dates,
+and optionally creating Git branches.
+"""
+
+from datetime import UTC, datetime
+
+import structlog
+
+from roadmap.common.console import get_console
+from roadmap.core.domain import Status
+
+logger = structlog.get_logger()
+
+
+class StartIssueService:
+    """Service for starting work on issues."""
+
+    def __init__(self, core):
+        """Initialize service with core instance.
+
+        Args:
+            core: RoadmapCore instance
+        """
+        self.core = core
+        self._console = get_console()
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Start Date Parsing
+    # ─────────────────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def parse_start_date(date_str: str | None) -> datetime:
+        """Parse start date from string input.
+
+        Args:
+            date_str: Date string in format YYYY-MM-DD or YYYY-MM-DD HH:MM
+
+        Returns:
+            Parsed datetime, or current time if not provided or invalid
+
+        Raises:
+            ValueError: If date string is invalid
+        """
+        if not date_str:
+            return datetime.now(UTC)
+
+        # Try full datetime format first
+        try:
+            return datetime.strptime(date_str, "%Y-%m-%d %H:%M")
+        except ValueError as e:
+            logger.debug(
+                "date_parse_failed",
+                date_str=date_str,
+                error=str(e),
+                action="parse_datetime",
+            )
+
+        # Try date-only format
+        try:
+            return datetime.strptime(date_str, "%Y-%m-%d")
+        except ValueError as e:
+            raise ValueError(
+                f"Invalid date format: {date_str}. Use YYYY-MM-DD or YYYY-MM-DD HH:MM"
+            ) from e
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Start Work Workflow
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def start_work(self, issue_id: str, start_date: datetime) -> object | None:
+        """Update issue to start work.
+
+        Sets status to IN_PROGRESS, sets actual start date, and initializes
+        progress tracking.
+
+        Args:
+            issue_id: ID of issue to start
+            start_date: Datetime to set as start time
+
+        Returns:
+            Updated issue if successful, None otherwise
+        """
+        return self.core.issues.update(
+            issue_id,
+            actual_start_date=start_date,
+            status=Status.IN_PROGRESS,
+            progress_percentage=0.0,
+        )
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Branch Creation Decision
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def should_create_branch(self, git_branch_flag: bool) -> bool:
+        """Determine if git branch should be created based on flag and config.
+
+        Currently only respects explicit --create-branch flag.
+        Auto-creation can be re-enabled via config in the future.
+
+        Args:
+            git_branch_flag: Whether --create-branch flag was passed
+
+        Returns:
+            Whether to create a branch
+        """
+        if git_branch_flag:
+            return True
+
+        # Check config for auto_branch default (disabled for now - can be re-enabled later)
+        return False
+
+    # ─────────────────────────────────────────────────────────────────────────
+    # Display Results
+    # ─────────────────────────────────────────────────────────────────────────
+
+    def display_started(self, issue, start_date: datetime) -> None:
+        """Display success message for started issue.
+
+        Args:
+            issue: Issue that was started
+            start_date: Datetime when work started
+        """
+        self._console.print(f"🚀 Started work on: {issue.title}", style="bold green")
+        self._console.print(
+            f"   Started: {start_date.strftime('%Y-%m-%d %H:%M')}", style="cyan"
+        )
+        self._console.print("   Status: In Progress", style="yellow")
+
+    def display_branch_created(self, branch_name: str, checkout: bool) -> None:
+        """Display git branch creation success.
+
+        Args:
+            branch_name: Name of created branch
+            checkout: Whether branch was checked out
+        """
+        self._console.print(
+            f"🌿 Created Git branch: {branch_name}",
+            style="green",
+        )
+        if checkout:
+            self._console.print(
+                f"✅ Checked out branch: {branch_name}",
+                style="green",
+            )
+
+    def display_branch_warning(self) -> None:
+        """Display warning when branch creation fails."""
+        try:
+            status_output = (
+                self.core.git._run_git_command(["status", "--porcelain"]) or ""
+            )
+            if status_output.strip():
+                self._console.print(
+                    "⚠️  Working tree has uncommitted changes — branch creation skipped. Use --force to override.",
+                    style="yellow",
+                )
+            else:
+                self._console.print(
+                    "⚠️  Failed to create or checkout branch. See git for details.",
+                    style="yellow",
+                )
+        except Exception as e:
+            logger.debug(
+                "branch_creation_failed",
+                operation="create_branch",
+                error=str(e),
+                action="Showing user message",
+            )
+            self._console.print(
+                "⚠️  Failed to create or checkout branch. See git for details.",
+                style="yellow",
+            )

roadmap/core/services/issue_helpers/__init__.py

@@ -0,0 +1,18 @@
+"""Issue-related helper utilities for filtering, updating, and management.
+
+DEPRECATED: This module is deprecated. Import directly from issue_filter_service instead.
+Example: from roadmap.core.services.issue.issue_filter_service import IssueQueryService
+"""
+
+# Backward compatibility re-exports
+from roadmap.core.services.issue.issue_filter_service import (
+    IssueFilterValidator,
+    IssueQueryService,
+    WorkloadCalculator,
+)
+
+__all__ = [
+    "IssueFilterValidator",
+    "IssueQueryService",
+    "WorkloadCalculator",
+]

roadmap/core/services/issue_helpers/issue_filters.py

@@ -0,0 +1,296 @@
+"""Issue filtering logic extracted from complex CLI command."""
+
+from datetime import UTC
+
+from roadmap.core.domain import Issue, Priority, Status
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+
+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):
+        """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"