roadmap-cli 0.1.1__py3-none-any.whl

roadmap/infrastructure/coordination/issue_operations.py

@@ -0,0 +1,456 @@
+"""Issue Operations Module - Handles all issue-related CRUD operations.
+
+This module encapsulates issue management responsibilities extracted from RoadmapCore,
+including creating, reading, updating, and deleting issues, as well as issue assignment
+and milestone-related queries.
+
+Responsibilities:
+- Issue CRUD operations (create, list, get, update, delete)
+- Issue assignment to milestones
+- Issue queries (backlog, by milestone, grouped by milestone)
+- Issue movement between milestones
+"""
+
+from difflib import get_close_matches
+from pathlib import Path
+
+from roadmap.adapters.persistence.parser import IssueParser
+from roadmap.common.cache import SessionCache
+from roadmap.common.utils.timezone_utils import now_utc
+from roadmap.core.domain import (
+    Issue,
+    IssueType,
+    Priority,
+    Status,
+)
+from roadmap.core.models import IssueCreateServiceParams, IssueUpdateServiceParams
+from roadmap.core.services import IssueService
+
+
+class IssueOperations:
+    """Manager for issue-related operations."""
+
+    # Cache TTL in seconds
+    _cache_ttl = 60
+
+    def __init__(self, issue_service: IssueService, issues_dir: Path):
+        """Initialize issue operations manager.
+
+        Args:
+            issue_service: The IssueService instance for database operations
+            issues_dir: Path to the issues directory
+        """
+        self.issue_service = issue_service
+        self.issues_dir = issues_dir
+        # Cache for get_issues_by_milestone results (instance-level to avoid test pollution)
+        self._milestone_cache = SessionCache()
+
+    def create_issue(
+        self,
+        title: str,
+        priority: Priority = Priority.MEDIUM,
+        issue_type: IssueType = IssueType.OTHER,
+        milestone: str | None = None,
+        labels: list[str] | None = None,
+        assignee: str | None = None,
+        estimated_hours: float | None = None,
+        depends_on: list[str] | None = None,
+        blocks: list[str] | None = None,
+        status: str | None = None,
+        content: str | None = None,
+    ) -> Issue:
+        """Create a new issue.
+
+        Args:
+            title: Issue title
+            priority: Issue priority (default: MEDIUM)
+            issue_type: Type of issue (default: OTHER)
+            milestone: Milestone name (optional)
+            labels: List of labels (optional)
+            assignee: Assigned user (optional)
+            estimated_hours: Estimated hours to complete (optional)
+            depends_on: List of issue IDs this depends on (optional)
+            blocks: List of issue IDs this blocks (optional)
+            status: Issue status (optional, defaults to TODO)
+            content: Issue content/description (optional)
+
+        Returns:
+            Created Issue object
+        """
+        # Create service params dataclass from individual arguments
+        params = IssueCreateServiceParams(
+            title=title,
+            priority=priority.value
+            if isinstance(priority, Priority)
+            else str(priority),
+            issue_type=issue_type.value
+            if isinstance(issue_type, IssueType)
+            else str(issue_type),
+            milestone=milestone,
+            labels=labels or [],
+            assignee=assignee,
+            content=content,
+            estimate=estimated_hours,
+            depends_on=depends_on or [],
+            blocks=blocks or [],
+            status=status or "todo",
+        )
+
+        result = self.issue_service.create_issue(params)
+
+        # Invalidate milestone cache after creation
+        self._milestone_cache.clear()
+
+        return result
+
+    def list_issues(
+        self,
+        milestone: str | None = None,
+        status: Status | None = None,
+        priority: Priority | None = None,
+        issue_type: IssueType | None = None,
+        assignee: str | None = None,
+    ) -> list[Issue]:
+        """List issues with optional filtering.
+
+        Args:
+            milestone: Filter by milestone name (optional)
+            status: Filter by issue status (optional)
+            priority: Filter by priority (optional)
+            issue_type: Filter by issue type (optional)
+            assignee: Filter by assignee (optional)
+
+        Returns:
+            List of Issue objects matching the filters
+        """
+        return self.issue_service.list_issues(
+            milestone=milestone,
+            status=status,
+            priority=priority,
+            issue_type=issue_type,
+            assignee=assignee,
+        )
+
+    def list_all_including_archived(self) -> list[Issue]:
+        """List all issues including archived ones.
+
+        Used by sync operations that need to compare both active and archived issues.
+
+        Returns:
+            List of all Issue objects (both active and archived)
+        """
+        return self.issue_service.list_all_including_archived()
+
+    def get_issue(self, issue_id: str) -> Issue | None:
+        """Get a specific issue by ID.
+
+        Args:
+            issue_id: The issue ID to retrieve
+
+        Returns:
+            Issue object if found, None otherwise
+        """
+        return self.issue_service.get_issue(issue_id)
+
+    def _build_update_params(
+        self, issue_id: str, updates: dict
+    ) -> IssueUpdateServiceParams:
+        """Build IssueUpdateServiceParams from a raw updates dict."""
+        params_dict: dict = {"issue_id": issue_id}
+
+        if "title" in updates:
+            params_dict["title"] = updates["title"]
+        if "priority" in updates:
+            priority = updates["priority"]
+            params_dict["priority"] = (
+                priority.value if isinstance(priority, Priority) else priority
+            )
+        if "status" in updates:
+            status = updates["status"]
+            params_dict["status"] = (
+                status.value if isinstance(status, Status) else status
+            )
+        if "assignee" in updates:
+            params_dict["assignee"] = updates["assignee"]
+        if "milestone" in updates:
+            params_dict["milestone"] = updates["milestone"]  # Can be None!
+        if "description" in updates:
+            params_dict["content"] = updates["description"]
+        if "estimate" in updates:
+            params_dict["estimate"] = updates["estimate"]
+        if "reason" in updates:
+            params_dict["reason"] = updates["reason"]
+
+        return IssueUpdateServiceParams(**params_dict)
+
+    _HANDLED_UPDATE_FIELDS = frozenset(
+        {
+            "issue_id",
+            "title",
+            "priority",
+            "status",
+            "assignee",
+            "milestone",
+            "content",
+            "estimate",
+            "reason",
+        }
+    )
+
+    def _apply_extra_fields_to_result(self, result: Issue, updates: dict) -> None:
+        """Apply update fields not handled by the service layer, then save to file."""
+        for field, value in updates.items():
+            if field not in self._HANDLED_UPDATE_FIELDS and hasattr(result, field):
+                setattr(result, field, value)
+
+        # Save extra fields to disk when the service layer didn't already do so.
+        # Milestone updates are written by the repository's own save(); skip to avoid
+        # overwriting a potentially relocated file path.
+        if result.file_path and "milestone" not in updates:
+            IssueParser.save_issue_file(result, Path(result.file_path))
+
+    def update_issue(self, issue_id: str, **updates) -> Issue | None:
+        """Update an existing issue.
+
+        Args:
+            issue_id: The issue ID to update
+            **updates: Fields to update
+
+        Returns:
+            Updated Issue object if found, None otherwise
+        """
+        params = self._build_update_params(issue_id, updates)
+        result = self.issue_service.update_issue(params)
+
+        if result is not None:
+            self._apply_extra_fields_to_result(result, updates)
+            self._milestone_cache.clear()
+
+        return result
+
+    def delete_issue(self, issue_id: str) -> bool:
+        """Delete an issue.
+
+        Args:
+            issue_id: The issue ID to delete
+
+        Returns:
+            True if issue was deleted, False if not found
+        """
+        result = self.issue_service.delete_issue(issue_id)
+
+        # Invalidate milestone cache after deletion
+        if result:
+            self._milestone_cache.clear()
+
+        return result
+
+    def assign_issue_to_milestone(self, issue_id: str, milestone_name: str) -> bool:
+        """Assign an issue to a milestone.
+
+        Args:
+            issue_id: The issue ID to assign
+            milestone_name: The milestone name to assign to
+
+        Returns:
+            True if assignment successful, False if issue or milestone not found
+        """
+        issue = self.get_issue(issue_id)
+        if not issue:
+            return False
+
+        # Validate milestone exists by checking file using same logic as Milestone.filename
+        safe_name = "".join(
+            c for c in milestone_name if c.isalnum() or c in (" ", "-", "_")
+        ).strip()
+        safe_name = safe_name.replace(" ", "-").lower()
+        milestone_file = self.issues_dir.parent / "milestones" / f"{safe_name}.md"
+        if not milestone_file.exists():
+            return False
+
+        # Use the repository's update method which handles file movement correctly
+        return self.update_issue(issue_id, milestone=milestone_name) is not None
+
+    def get_backlog_issues(self) -> list[Issue]:
+        """Get all issues not assigned to any milestone (backlog).
+
+        Returns:
+            List of Issue objects in the backlog
+        """
+        all_issues = self.list_issues()
+        return [issue for issue in all_issues if issue.is_backlog]
+
+    def get_milestone_issues(self, milestone_name: str) -> list[Issue]:
+        """Get all issues assigned to a specific milestone.
+
+        Args:
+            milestone_name: The milestone name to filter by
+
+        Returns:
+            List of Issue objects assigned to the milestone
+        """
+        all_issues = self.list_issues()
+        return [issue for issue in all_issues if issue.milestone == milestone_name]
+
+    def get_issues_by_milestone(self) -> dict[str, list[Issue]]:
+        """Get all issues grouped by milestone, including backlog.
+
+        Returns:
+            Dictionary mapping milestone names to lists of Issue objects,
+            with a "Backlog" key for unassigned issues
+        """
+        # Check cache first
+        cached = self._milestone_cache.get("all_milestones")
+        if cached is not None:
+            return cached
+
+        all_issues = self.list_issues()
+        grouped: dict[str, list[Issue]] = {"Backlog": []}
+
+        # Add backlog issues
+        for issue in all_issues:
+            if issue.is_backlog:
+                grouped["Backlog"].append(issue)
+            else:
+                milestone_name = issue.milestone
+                if milestone_name is None:
+                    # Issues without milestone go to Backlog
+                    grouped["Backlog"].append(issue)
+                else:
+                    if milestone_name not in grouped:
+                        grouped[milestone_name] = []
+                    grouped[milestone_name].append(issue)
+
+        # Cache the result with TTL
+        self._milestone_cache.set("all_milestones", grouped, ttl=self._cache_ttl)
+
+        return grouped
+
+    def move_issue_to_milestone(
+        self, issue_id: str, milestone_name: str | None
+    ) -> bool:
+        """Move an issue to a milestone or to backlog if milestone_name is None.
+
+        Args:
+            issue_id: The issue ID to move
+            milestone_name: The target milestone name, or None for backlog
+
+        Returns:
+            True if move successful, False if issue not found or milestone invalid
+        """
+        issue = self.get_issue(issue_id)
+        if not issue:
+            return False
+
+        # Validate milestone exists if milestone_name is provided (None is valid for backlog)
+        if milestone_name is not None:
+            # Check if milestone file exists
+            safe_name = "".join(
+                c for c in milestone_name if c.isalnum() or c in (" ", "-", "_")
+            ).strip()
+            safe_name = safe_name.replace(" ", "-").lower()
+            milestone_file = self.issues_dir.parent / "milestones" / f"{safe_name}.md"
+            if not milestone_file.exists():
+                return False
+
+        # Update issue milestone using the repository method which handles file movement
+        updated_issue = self.update_issue(issue_id, milestone=milestone_name)
+
+        # Invalidate milestone cache after moving
+        self._milestone_cache.clear()
+
+        return updated_issue is not None
+
+    def batch_assign_to_milestone(
+        self,
+        issue_ids: list[str],
+        milestone_name: str,
+        preloaded_issues: list[Issue] | None = None,
+    ) -> tuple[int, int]:
+        """Batch assign multiple issues to a milestone in a single pass.
+
+        This method is more efficient than calling assign_issue_to_milestone
+        in a loop, as it validates the milestone once. If preloaded_issues
+        is provided, it uses those instead of scanning the filesystem.
+
+        Args:
+            issue_ids: List of issue IDs to assign
+            milestone_name: The milestone name to assign to
+            preloaded_issues: Optional pre-loaded list of issues (avoids filesystem scan)
+
+        Returns:
+            Tuple of (successful_count, failed_count)
+        """
+        # Validate milestone exists once upfront
+        safe_name = "".join(
+            c for c in milestone_name if c.isalnum() or c in (" ", "-", "_")
+        ).strip()
+        safe_name = safe_name.replace(" ", "-").lower()
+        milestone_file = self.issues_dir.parent / "milestones" / f"{safe_name}.md"
+        if not milestone_file.exists():
+            return 0, len(issue_ids)
+
+        # Load all issues once (or use preloaded)
+        if preloaded_issues is not None:
+            all_issues = preloaded_issues
+        else:
+            all_issues = self.list_issues()
+
+        issue_by_id = {issue.id: issue for issue in all_issues}
+
+        successful = 0
+        failed = 0
+
+        # Update and save only the issues we need to modify
+        for issue_id in issue_ids:
+            if issue_id not in issue_by_id:
+                failed += 1
+                continue
+
+            issue = issue_by_id[issue_id]
+            issue.milestone = milestone_name
+            issue.updated = now_utc()
+
+            # Save the issue
+            if hasattr(issue, "file_path") and issue.file_path:
+                issue_path = Path(issue.file_path)
+            else:
+                issue_path = self.issues_dir / issue.filename
+
+            try:
+                IssueParser.save_issue_file(issue, issue_path)
+                successful += 1
+            except Exception:
+                failed += 1
+
+        # Invalidate caches after batch assignment
+        if successful > 0:
+            self._milestone_cache.clear()
+
+        return successful, failed
+
+    def get_similar_milestone_names(
+        self, milestone_name: str, max_results: int = 3
+    ) -> list[str]:
+        """Find milestone names similar to the given name.
+
+        Useful for suggesting corrections when a user typos a milestone name.
+
+        Args:
+            milestone_name: The milestone name to find similar matches for
+            max_results: Maximum number of suggestions to return
+
+        Returns:
+            List of similar milestone names found
+        """
+        # Get all available milestone names
+        milestones_dir = self.issues_dir.parent / "milestones"
+        if not milestones_dir.exists():
+            return []
+
+        available_milestones = [f.stem for f in milestones_dir.glob("*.md")]
+
+        # Find close matches
+        return get_close_matches(
+            milestone_name, available_milestones, n=max_results, cutoff=0.6
+        )

roadmap/infrastructure/coordination/milestone_coordinator.py

@@ -0,0 +1,135 @@
+"""Milestone Coordinator - Coordinates milestone-related operations.
+
+Extracted from RoadmapCore to reduce god object complexity.
+Provides a focused API for all milestone-related concerns.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+from roadmap.core.domain import Milestone
+from roadmap.infrastructure.coordination.milestone_operations import MilestoneOperations
+from roadmap.infrastructure.validation.milestone_consistency_validator import (
+    MilestoneConsistencyValidator,
+)
+
+if TYPE_CHECKING:
+    from roadmap.infrastructure.coordination.core import RoadmapCore
+
+
+class MilestoneCoordinator:
+    """Coordinates all milestone-related operations."""
+
+    def __init__(
+        self,
+        milestone_ops: MilestoneOperations,
+        milestones_dir,
+        core: RoadmapCore | None = None,
+    ):
+        """Initialize coordinator with milestone operations manager.
+
+        Args:
+            milestone_ops: MilestoneOperations instance
+            milestones_dir: Path to milestones directory
+            core: RoadmapCore instance for initialization checks
+        """
+        self._ops = milestone_ops
+        self._consistency_validator = MilestoneConsistencyValidator(milestones_dir)
+        self._core = core
+
+    # CRUD Operations
+    def create(
+        self,
+        name: str,
+        headline: str = "",
+        due_date: datetime | None = None,
+        status: str | None = None,
+        project_id: str | None = None,
+    ) -> Milestone:
+        """Create a new milestone."""
+        milestone = self._ops.create_milestone(
+            name=name, headline=headline, due_date=due_date, status=status
+        )
+
+        # Assign to project if provided
+        if project_id:
+            milestone.project_id = project_id
+
+        return milestone
+
+    def list(self) -> list[Milestone]:
+        """List all milestones."""
+        return self._ops.list_milestones()
+
+    def get(self, name: str) -> Milestone | None:
+        """Get a specific milestone by name (searches by YAML name field, not filename)."""
+        return self._ops.get_milestone(name)
+
+    def update(
+        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
+        """
+        return self._ops.update_milestone(
+            name=name,
+            headline=headline,
+            due_date=due_date,
+            clear_due_date=clear_due_date,
+            status=status,
+            project_id=project_id,
+        )
+
+    def delete(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
+        """
+        return self._ops.delete_milestone(name)
+
+    def get_progress(self, milestone_name: str) -> dict[str, Any]:
+        """Get progress statistics for a milestone."""
+        return self._ops.get_milestone_progress(milestone_name)
+
+    def get_next(self) -> Milestone | None:
+        """Get the next upcoming milestone based on due date."""
+        return self._ops.get_next_milestone()
+
+    # Consistency and Validation
+    def validate_naming_consistency(self) -> list[dict[str, str]]:
+        """Check for inconsistencies between milestone filenames and name fields.
+
+        Returns:
+            List of dictionaries with inconsistency details
+        """
+        return self._consistency_validator.validate()
+
+    def fix_naming_consistency(self) -> dict[str, list[str]]:
+        """Fix milestone filename inconsistencies by renaming files to match name fields.
+
+        Returns:
+            Dictionary with 'renamed' and 'errors' lists
+        """
+        return self._consistency_validator.fix()