roadmap-cli 0.1.1__py3-none-any.whl

roadmap/infrastructure/coordination/milestone_operations.py

@@ -0,0 +1,201 @@
+"""Milestone Operations Module - Handles all milestone-related CRUD operations.
+
+This module encapsulates milestone management responsibilities extracted from RoadmapCore,
+including creating, reading, updating, and deleting milestones, as well as milestone-related
+queries and progress tracking.
+
+Responsibilities:
+- Milestone CRUD operations (create, list, get, update, delete)
+- Milestone progress tracking
+- Next milestone calculation
+"""
+
+from datetime import datetime
+from typing import Any
+
+from roadmap.common.errors.error_standards import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+from roadmap.core.domain import Milestone, MilestoneStatus
+from roadmap.core.services import MilestoneService
+
+logger = get_logger(__name__)
+
+
+class MilestoneOperations:
+    """Manager for milestone-related operations."""
+
+    def __init__(self, milestone_service: MilestoneService):
+        """Initialize milestone operations manager.
+
+        Args:
+            milestone_service: The MilestoneService instance for database operations
+        """
+        self.milestone_service = milestone_service
+
+    @safe_operation(OperationType.CREATE, "Milestone", include_traceback=True)
+    def create_milestone(
+        self,
+        name: str,
+        headline: str = "",
+        due_date: datetime | None = None,
+        status: str | None = None,
+    ) -> Milestone:
+        """Create a new milestone.
+
+        Args:
+            name: Milestone name
+            headline: Milestone headline (short summary)
+            due_date: Due date for the milestone (optional)
+            status: Milestone status (optional, defaults to OPEN)
+
+        Returns:
+            Created Milestone object
+        """
+        logger.info(
+            "creating_milestone",
+            milestone_name=name,
+            has_headline=headline is not None,
+            has_due_date=due_date is not None,
+            status=status,
+        )
+        return self.milestone_service.create_milestone(
+            name=name, headline=headline, due_date=due_date, status=status
+        )
+
+    @safe_operation(OperationType.READ, "Milestone")
+    def list_milestones(self) -> list[Milestone]:
+        """List all milestones.
+
+        Returns:
+            List of Milestone objects
+        """
+        logger.info("listing_milestones")
+        return self.milestone_service.list_milestones()
+
+    @safe_operation(OperationType.READ, "Milestone")
+    def get_milestone(self, name: str) -> Milestone | None:
+        """Get a specific milestone by name.
+
+        Args:
+            name: Name of the milestone (searches by YAML name field, not filename)
+
+        Returns:
+            Milestone object if found, None otherwise
+        """
+        logger.info("getting_milestone", milestone_name=name)
+        return self.milestone_service.get_milestone(name)
+
+    @safe_operation(OperationType.DELETE, "Milestone", include_traceback=True)
+    def delete_milestone(self, name: str) -> bool:
+        """Delete a milestone and unassign all issues from it.
+
+        Args:
+            name: Name of the milestone to delete
+
+        Returns:
+            True if milestone was deleted, False if not found
+        """
+        logger.info("deleting_milestone", milestone_name=name)
+        return self.milestone_service.delete_milestone(name)
+
+    @safe_operation(OperationType.UPDATE, "Milestone")
+    def update_milestone(
+        self,
+        name: str,
+        headline: str | None = None,
+        due_date: datetime | None = None,
+        clear_due_date: bool = False,
+        status: str | None = None,
+        project_id: str | None = None,
+    ) -> bool:
+        """Update a milestone's properties.
+
+        Args:
+            name: Name of the milestone to update
+            headline: New headline (None to keep current)
+            due_date: New due date (None to keep current)
+            clear_due_date: If True, remove the due date
+            status: New status (None to keep current)
+            project_id: Project ID to assign milestone to
+
+        Returns:
+            True if milestone was updated, False if not found or error occurred
+        """
+        from roadmap.common.errors.exceptions import UpdateError
+
+        logger.info(
+            "updating_milestone",
+            milestone_name=name,
+            has_headline=headline is not None,
+            has_due_date=due_date is not None,
+            clear_due_date=clear_due_date,
+            has_status=status is not None,
+            has_project_id=project_id is not None,
+        )
+        try:
+            return (
+                self.milestone_service.update_milestone(
+                    name=name,
+                    headline=headline,
+                    due_date=due_date,
+                    clear_due_date=clear_due_date,
+                    status=status,
+                    project_id=project_id,
+                )
+                is not None
+            )
+        except UpdateError as e:
+            logger.error(
+                "milestone_update_failed",
+                name=name,
+                error=str(e),
+                severity="operational",
+            )
+            return False
+
+    @safe_operation(OperationType.READ, "Milestone")
+    def get_milestone_progress(self, milestone_name: str) -> dict[str, Any]:
+        """Get progress statistics for a milestone.
+
+        Args:
+            milestone_name: Name of the milestone
+
+        Returns:
+            Dictionary containing progress metrics (completed, total, percentage, etc.)
+        """
+        logger.info("getting_milestone_progress", milestone_name=milestone_name)
+        return self.milestone_service.get_milestone_progress(milestone_name)
+
+    def get_next_milestone(self) -> Milestone | None:
+        """Get the next upcoming milestone based on due date.
+
+        Returns:
+            The upcoming milestone with the earliest due date, or None if no upcoming milestones
+        """
+        milestones = self.list_milestones()
+
+        # Filter for open milestones with due dates
+        upcoming_milestones = [
+            m
+            for m in milestones
+            if m.status == MilestoneStatus.OPEN and m.due_date is not None
+        ]
+
+        if not upcoming_milestones:
+            return None
+
+        # Sort by due date and return the earliest
+        # Handle timezone-aware vs timezone-naive datetime comparison
+        def get_sortable_date(milestone: Milestone) -> datetime:
+            """Extract sortable date from milestone."""
+            due_date = milestone.due_date
+            # due_date should not be None since we filtered above, but be safe
+            if due_date is None:
+                return datetime.max  # Put None dates at the end
+            # Convert timezone-aware dates to naive for comparison
+            if due_date.tzinfo is not None:
+                return due_date.replace(tzinfo=None)
+            return due_date
+
+        upcoming_milestones.sort(key=get_sortable_date)
+        return upcoming_milestones[0]

roadmap/infrastructure/coordination/project_coordinator.py

@@ -0,0 +1,113 @@
+"""Project Coordinator - Coordinates project-related operations.
+
+Extracted from RoadmapCore to reduce god object complexity.
+Provides a focused API for all project-related concerns.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from roadmap.core.domain import Project
+from roadmap.infrastructure.coordination.project_operations import ProjectOperations
+
+if TYPE_CHECKING:
+    from roadmap.infrastructure.coordination.core import RoadmapCore
+
+
+class ProjectCoordinator:
+    """Coordinates all project-related operations."""
+
+    def __init__(self, project_ops: ProjectOperations, core: RoadmapCore | None = None):
+        """Initialize coordinator with project operations manager.
+
+        Args:
+            project_ops: ProjectOperations instance
+            core: RoadmapCore instance for initialization checks
+        """
+        self._ops = project_ops
+        self._core = core
+
+    def list(self) -> list[Project]:
+        """List all projects."""
+        return self._ops.list_projects()
+
+    def get(self, project_id: str) -> Project | None:
+        """Get a specific project by ID or name.
+
+        Tries to find project by ID first, then by name as fallback.
+        """
+        # Try direct ID lookup first
+        project = self._ops.get_project(project_id)
+        if project:
+            return project
+
+        # Fallback: try to find by name
+        for project in self._ops.list_projects():
+            if project.name.lower() == project_id.lower():
+                return project
+
+        return None
+
+    def create(
+        self,
+        name: str,
+        headline: str = "",
+        milestones: list[str] | None = None,
+        status: str | None = None,
+    ) -> Project:
+        """Create a new project.
+
+        Args:
+            name: Project name
+            headline: Project headline (short summary)
+            milestones: List of milestone names (optional)
+            status: Project status (optional)
+
+        Returns:
+            Created Project object
+        """
+        return self._ops.create_project(
+            name=name,
+            headline=headline,
+            milestones=milestones or [],
+            status=status,
+        )
+
+    def save(self, project: Project) -> bool:
+        """Save an updated project to disk."""
+        return self._ops.save_project(project)
+
+    def update(self, project_id: str, **updates) -> Project | None:
+        """Update a project with the given fields.
+
+        Args:
+            project_id: Project identifier
+            **updates: Fields to update (name, description, status, priority, etc.)
+
+        Returns:
+            Updated Project object if successful, None if not found
+        """
+        return self._ops.update_project(project_id, **updates)
+
+    def delete(self, project_id: str) -> bool:
+        """Delete a project.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            True if deletion successful, False otherwise
+        """
+        return self._ops.delete_project(project_id)
+
+    def complete(self, project_id: str) -> Project | None:
+        """Mark a project as completed.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            Updated Project object if successful, None if not found
+        """
+        return self._ops.complete_project(project_id)

roadmap/infrastructure/coordination/project_operations.py

@@ -0,0 +1,144 @@
+"""Project Operations Module - Handles all project-related CRUD operations.
+
+This module encapsulates project management responsibilities extracted from RoadmapCore,
+including creating, reading, updating, and managing projects.
+
+Responsibilities:
+- Project CRUD operations (list, get, save, update)
+"""
+
+from roadmap.common.errors.error_standards import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+from roadmap.core.domain import Project
+from roadmap.core.services import ProjectService
+
+logger = get_logger(__name__)
+
+
+class ProjectOperations:
+    """Manager for project-related operations."""
+
+    def __init__(self, project_service: ProjectService):
+        """Initialize project operations manager.
+
+        Args:
+            project_service: The ProjectService instance for database operations
+        """
+        self.project_service = project_service
+
+    @safe_operation(OperationType.READ, "Project")
+    def list_projects(self) -> list[Project]:
+        """List all projects.
+
+        Returns:
+            List of Project objects
+        """
+        logger.info("listing_projects")
+        return self.project_service.list_projects()
+
+    @safe_operation(OperationType.READ, "Project")
+    def get_project(self, project_id: str) -> Project | None:
+        """Get a specific project by ID.
+
+        Args:
+            project_id: The project ID to retrieve
+
+        Returns:
+            Project object if found, None otherwise
+        """
+        logger.info("getting_project", project_id=project_id)
+        return self.project_service.get_project(project_id)
+
+    @safe_operation(OperationType.CREATE, "Project", include_traceback=True)
+    def create_project(
+        self,
+        name: str,
+        headline: str = "",
+        milestones: list[str] | None = None,
+        status: str | None = None,
+    ) -> Project:
+        """Create a new project.
+
+        Args:
+            name: Project name
+            headline: Project headline (short summary)
+            milestones: List of milestone names (optional)
+            status: Project status (optional)
+
+        Returns:
+            Created Project object
+        """
+        logger.info(
+            "creating_project",
+            project_name=name,
+            has_headline=headline is not None,
+            milestone_count=len(milestones or []),
+            status=status,
+        )
+        return self.project_service.create_project(
+            name=name,
+            headline=headline,
+            milestones=milestones or [],
+            status=status,
+        )
+
+    @safe_operation(OperationType.UPDATE, "Project")
+    def save_project(self, project: Project) -> bool:
+        """Save an updated project to disk.
+
+        Args:
+            project: The Project object to save
+
+        Returns:
+            True if save successful, False otherwise
+        """
+        logger.info(
+            "saving_project",
+            project_id=project.id,
+            project_name=project.name,
+        )
+        return self.project_service.save_project(project)
+
+    @safe_operation(OperationType.UPDATE, "Project")
+    def update_project(self, project_id: str, **updates) -> Project | None:
+        """Update a project with the given fields.
+
+        Args:
+            project_id: Project identifier
+            **updates: Fields to update (name, description, status, priority, etc.)
+
+        Returns:
+            Updated Project object if successful, None if not found
+        """
+        logger.info(
+            "updating_project",
+            project_id=project_id,
+            update_fields=list(updates.keys()),
+        )
+        return self.project_service.update_project(project_id, **updates)
+
+    @safe_operation(OperationType.DELETE, "Project", include_traceback=True)
+    def delete_project(self, project_id: str) -> bool:
+        """Delete a project.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            True if deletion successful, False otherwise
+        """
+        logger.info("deleting_project", project_id=project_id)
+        return self.project_service.delete_project(project_id)
+
+    @safe_operation(OperationType.UPDATE, "Project")
+    def complete_project(self, project_id: str) -> Project | None:
+        """Mark a project as completed.
+
+        Args:
+            project_id: Project identifier
+
+        Returns:
+            Updated Project object if successful, None if not found
+        """
+        logger.info("completing_project", project_id=project_id)
+        return self.project_service.complete_project(project_id)

roadmap/infrastructure/coordination/team_coordinator.py

@@ -0,0 +1,107 @@
+"""Team Coordinator - Coordinates team and user-related operations.
+
+Extracted from RoadmapCore to reduce god object complexity.
+Provides a focused API for all team and user management concerns.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from roadmap.common.errors.error_standards import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+from roadmap.core.domain import Issue
+from roadmap.infrastructure.coordination.user_operations import UserOperations
+
+if TYPE_CHECKING:
+    from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = get_logger(__name__)
+
+
+class TeamCoordinator:
+    """Coordinates all team and user-related operations."""
+
+    def __init__(self, user_ops: UserOperations, core: RoadmapCore | None = None):
+        """Initialize coordinator with user operations manager.
+
+        Args:
+            user_ops: UserOperations instance
+            core: RoadmapCore instance for initialization checks
+        """
+        self._ops = user_ops
+        self._core = core
+
+    @safe_operation(OperationType.READ, "Team")
+    def get_members(self) -> list[str]:
+        """Get team members from GitHub repository.
+
+        Returns:
+            List of usernames if GitHub is configured, empty list otherwise
+        """
+        logger.info("getting_team_members")
+        return self._ops.get_team_members()
+
+    @safe_operation(OperationType.READ, "User")
+    def get_current_user(self) -> str | None:
+        """Get the current user from config.
+
+        Returns:
+            Current user's name from config if set, None otherwise
+        """
+        logger.info("getting_current_user")
+        return self._ops.get_current_user()
+
+    @safe_operation(OperationType.READ, "Issue")
+    def get_assigned_issues(self, assignee: str) -> list[Issue]:
+        """Get all issues assigned to a specific user."""
+        logger.info("getting_assigned_issues", assignee=assignee)
+        return self._ops.get_assigned_issues(assignee)
+
+    @safe_operation(OperationType.READ, "Issue")
+    def get_my_issues(self) -> list[Issue]:
+        """Get all issues assigned to the current user."""
+        logger.info("getting_my_issues")
+        return self._ops.get_my_issues()
+
+    @safe_operation(OperationType.READ, "Issue")
+    def get_all_assigned_issues(self) -> dict[str, list[Issue]]:
+        """Get all issues grouped by assignee.
+
+        Returns:
+            Dictionary mapping assignee usernames to their assigned issues
+        """
+        logger.info("getting_all_assigned_issues")
+        return self._ops.get_all_assigned_issues()
+
+    @safe_operation(OperationType.READ, "Assignee")
+    def validate_assignee(self, assignee: str) -> tuple[bool, str]:
+        """Validate an assignee using the identity management system.
+
+        Args:
+            assignee: Username to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        logger.info("validating_assignee", assignee=assignee)
+        return self._ops.validate_assignee(assignee)
+
+    @safe_operation(OperationType.READ, "Assignee")
+    def get_canonical_assignee(self, assignee: str) -> str:
+        """Get the canonical form of an assignee name.
+
+        Args:
+            assignee: Input assignee name
+
+        Returns:
+            Canonical assignee name (may be same as input if no mapping exists)
+        """
+        logger.info("getting_canonical_assignee", assignee=assignee)
+        return self._ops.get_canonical_assignee(assignee)
+
+    @safe_operation(OperationType.READ, "Team")
+    def get_cached_team_members(self) -> list[str]:
+        """Get team members with caching (5 minute cache)."""
+        logger.info("getting_cached_team_members")
+        return self._ops.get_cached_team_members()