roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/github/handlers/issues.py

@@ -0,0 +1,150 @@
+"""GitHub Issues handler."""
+
+from typing import Any
+
+from roadmap.adapters.github.handlers.base import BaseGitHubHandler
+
+
+class IssueHandler(BaseGitHubHandler):
+    """Handler for GitHub Issues API operations."""
+
+    def get_issues(
+        self,
+        state: str = "all",
+        labels: list[str] | None = None,
+        milestone: str | None = None,
+        assignee: str | None = None,
+        per_page: int = 100,
+    ) -> list[dict[str, Any]]:
+        """Get issues from the repository, handling pagination.
+
+        Automatically fetches all pages of issues. Returns complete list
+        regardless of total count.
+
+        Args:
+            state: Issue state ('open', 'closed', 'all')
+            labels: Optional list of label names to filter by
+            milestone: Optional milestone title to filter by
+            assignee: Optional assignee username to filter by
+            per_page: Items per page (max 100)
+
+        Returns:
+            List of all issue dictionaries across all pages
+        """
+        from structlog import get_logger
+
+        logger = get_logger()
+        logger.info("issue_handler_get_issues_called", state=state, per_page=per_page)
+
+        self._check_repository()
+
+        params = {
+            "state": state,
+            "sort": "created",
+            "direction": "desc",
+        }
+
+        if labels:
+            params["labels"] = ",".join(labels)
+        if milestone:
+            params["milestone"] = milestone
+        if assignee:
+            params["assignee"] = assignee
+
+        all_issues = self._paginate_request(
+            "GET",
+            f"/repos/{self.owner}/{self.repo}/issues",
+            params=params,
+            per_page=per_page,
+        )
+
+        issues_only = [issue for issue in all_issues if "pull_request" not in issue]
+        pr_count = len(all_issues) - len(issues_only)
+        if pr_count:
+            logger.info(
+                "issue_handler_prs_skipped",
+                skipped_count=pr_count,
+                issues_count=len(issues_only),
+            )
+
+        logger.info(
+            "issue_handler_get_issues_complete",
+            total_issues=len(issues_only),
+        )
+        return issues_only
+
+    def get_issue(self, issue_number: int) -> dict[str, Any]:
+        """Get a specific issue by number."""
+        self._check_repository()
+        response = self._make_request(
+            "GET", f"/repos/{self.owner}/{self.repo}/issues/{issue_number}"
+        )
+        return response.json()
+
+    def create_issue(
+        self,
+        title: str,
+        body: str | None = None,
+        labels: list[str] | None = None,
+        assignees: list[str] | None = None,
+        milestone: int | None = None,
+    ) -> dict[str, Any]:
+        """Create a new issue."""
+        self._check_repository()
+
+        data: dict[str, Any] = {"title": title}
+
+        if body:
+            data["body"] = body
+        if labels:
+            data["labels"] = labels
+        if assignees:
+            data["assignees"] = assignees
+        if milestone:
+            data["milestone"] = milestone
+
+        response = self._make_request(
+            "POST", f"/repos/{self.owner}/{self.repo}/issues", json=data
+        )
+        return response.json()
+
+    def update_issue(
+        self,
+        issue_number: int,
+        title: str | None = None,
+        body: str | None = None,
+        state: str | None = None,
+        labels: list[str] | None = None,
+        assignees: list[str] | None = None,
+        milestone: int | None = None,
+    ) -> dict[str, Any]:
+        """Update an existing issue."""
+        self._check_repository()
+
+        data = {}
+
+        if title is not None:
+            data["title"] = title
+        if body is not None:
+            data["body"] = body
+        if state is not None:
+            data["state"] = state
+        if labels is not None:
+            data["labels"] = labels
+        if assignees is not None:
+            data["assignees"] = assignees
+        if milestone is not None:
+            data["milestone"] = milestone
+
+        response = self._make_request(
+            "PATCH", f"/repos/{self.owner}/{self.repo}/issues/{issue_number}", json=data
+        )
+        return response.json()
+
+    def close_issue(self, issue_number: int) -> dict[str, Any]:
+        """Close an issue."""
+        return self.update_issue(issue_number, state="closed")
+
+    def reopen_issue(self, issue_number: int) -> dict[str, Any]:
+        """Reopen a closed issue."""
+        return self.update_issue(issue_number, state="open")

roadmap/adapters/github/handlers/labels.py

@@ -0,0 +1,164 @@
+"""GitHub Labels handler."""
+
+from typing import Any
+
+from structlog import get_logger
+
+from roadmap.adapters.github.handlers.base import BaseGitHubHandler
+from roadmap.core.domain import Priority, Status
+
+logger = get_logger()
+
+
+class LabelHandler(BaseGitHubHandler):
+    """Handler for GitHub Labels API operations."""
+
+    def get_labels(self) -> list[dict[str, Any]]:
+        """Get repository labels.
+
+        Handles pagination automatically - returns all labels.
+
+        Returns:
+            List of all repository labels across all pages
+        """
+        self._check_repository()
+        return self._paginate_request("GET", f"/repos/{self.owner}/{self.repo}/labels")
+
+    def create_label(
+        self, name: str, color: str, description: str | None = None
+    ) -> dict[str, Any]:
+        """Create a new label."""
+        self._check_repository()
+
+        data = {"name": name, "color": color.lstrip("#")}  # Remove # if present
+
+        if description:
+            data["description"] = description
+
+        response = self._make_request(
+            "POST", f"/repos/{self.owner}/{self.repo}/labels", json=data
+        )
+        return response.json()
+
+    def update_label(
+        self,
+        label_name: str,
+        new_name: str | None = None,
+        color: str | None = None,
+        description: str | None = None,
+    ) -> dict[str, Any]:
+        """Update an existing label."""
+        self._check_repository()
+
+        data = {}
+
+        if new_name is not None:
+            data["new_name"] = new_name
+        if color is not None:
+            data["color"] = color.lstrip("#")
+        if description is not None:
+            data["description"] = description
+
+        response = self._make_request(
+            "PATCH", f"/repos/{self.owner}/{self.repo}/labels/{label_name}", json=data
+        )
+        return response.json()
+
+    def delete_label(self, label_name: str) -> None:
+        """Delete a label."""
+        self._check_repository()
+        self._make_request(
+            "DELETE", f"/repos/{self.owner}/{self.repo}/labels/{label_name}"
+        )
+
+    def priority_to_labels(self, priority: Priority) -> list[str]:
+        """Convert priority to GitHub labels."""
+        priority_labels = {
+            Priority.CRITICAL: ["priority:critical"],
+            Priority.HIGH: ["priority:high"],
+            Priority.MEDIUM: ["priority:medium"],
+            Priority.LOW: ["priority:low"],
+        }
+        return priority_labels.get(priority, [])
+
+    def status_to_labels(self, status: Status) -> list[str]:
+        """Convert status to GitHub labels."""
+        status_labels = {
+            Status.TODO: ["status:todo"],
+            Status.IN_PROGRESS: ["status:in-progress"],
+            Status.BLOCKED: ["status:blocked"],
+            Status.REVIEW: ["status:review"],
+            Status.CLOSED: ["status:done"],
+        }
+        return status_labels.get(status, [])
+
+    def labels_to_priority(self, labels: list[str]) -> Priority | None:
+        """Extract priority from GitHub labels."""
+        label_names = [
+            label.get("name", label) if isinstance(label, dict) else label
+            for label in labels
+        ]
+
+        for label in label_names:
+            if label == "priority:critical":
+                return Priority.CRITICAL
+            elif label == "priority:high":
+                return Priority.HIGH
+            elif label == "priority:medium":
+                return Priority.MEDIUM
+            elif label == "priority:low":
+                return Priority.LOW
+
+        return None
+
+    def labels_to_status(self, labels: list[str]) -> Status | None:
+        """Extract status from GitHub labels."""
+        label_names = [
+            label.get("name", label) if isinstance(label, dict) else label
+            for label in labels
+        ]
+
+        for label in label_names:
+            if label == "status:todo":
+                return Status.TODO
+            elif label == "status:in-progress":
+                return Status.IN_PROGRESS
+            elif label == "status:blocked":
+                return Status.BLOCKED
+            elif label == "status:review":
+                return Status.REVIEW
+            elif label == "status:done":
+                return Status.CLOSED
+
+        return None
+
+    def setup_default_labels(self) -> None:
+        """Set up default labels for priority and status."""
+        self._check_repository()
+
+        # Priority labels
+        priority_labels = [
+            ("priority:critical", "FF0000", "Critical priority"),
+            ("priority:high", "FF9900", "High priority"),
+            ("priority:medium", "FFFF00", "Medium priority"),
+            ("priority:low", "00FF00", "Low priority"),
+        ]
+
+        # Status labels
+        status_labels = [
+            ("status:todo", "CCCCCC", "To do"),
+            ("status:in-progress", "0366D6", "In progress"),
+            ("status:blocked", "D73A49", "Blocked"),
+            ("status:review", "A371F7", "In review"),
+            ("status:done", "28A745", "Done"),
+        ]
+
+        existing_labels = [label["name"] for label in self.get_labels()]
+
+        for name, color, description in priority_labels + status_labels:
+            if name not in existing_labels:
+                try:
+                    self.create_label(name, color, description)
+                except Exception as e:
+                    # Label might have been created by another process
+                    logger.debug("create_label_failed", label_name=name, error=str(e))

roadmap/adapters/github/handlers/milestones.py

@@ -0,0 +1,104 @@
+"""GitHub Milestones handler."""
+
+from datetime import datetime
+from typing import Any
+
+from roadmap.adapters.github.handlers.base import BaseGitHubHandler
+
+
+class MilestoneHandler(BaseGitHubHandler):
+    """Handler for GitHub Milestones API operations."""
+
+    def get_milestones(self, state: str = "open") -> list[dict[str, Any]]:
+        """Get milestones from the repository.
+
+        Handles pagination automatically - returns all milestones.
+
+        Args:
+            state: Milestone state ('open', 'closed', 'all')
+
+        Returns:
+            List of all milestones across all pages
+        """
+        self._check_repository()
+
+        params = {"state": state}
+        return self._paginate_request(
+            "GET", f"/repos/{self.owner}/{self.repo}/milestones", params=params
+        )
+
+    def get_milestone(self, milestone_number: int) -> dict[str, Any]:
+        """Get a specific milestone by number."""
+        self._check_repository()
+        response = self._make_request(
+            "GET", f"/repos/{self.owner}/{self.repo}/milestones/{milestone_number}"
+        )
+        return response.json()
+
+    def create_milestone(
+        self,
+        title: str,
+        description: str | None = None,
+        due_date: datetime | None = None,
+        state: str = "open",
+    ) -> dict[str, Any]:
+        """Create a new milestone."""
+        self._check_repository()
+
+        data = {"title": title, "state": state}
+
+        if description:
+            data["description"] = description
+        if due_date:
+            # GitHub expects ISO 8601 format with timezone (Z for UTC)
+            if due_date.tzinfo is None:
+                # Assume UTC for naive datetime
+                data["due_on"] = due_date.isoformat() + "Z"
+            else:
+                data["due_on"] = due_date.isoformat()
+
+        response = self._make_request(
+            "POST", f"/repos/{self.owner}/{self.repo}/milestones", json=data
+        )
+        return response.json()
+
+    def update_milestone(
+        self,
+        milestone_number: int,
+        title: str | None = None,
+        description: str | None = None,
+        due_date: datetime | None = None,
+        state: str | None = None,
+    ) -> dict[str, Any]:
+        """Update an existing milestone."""
+        self._check_repository()
+
+        data = {}
+
+        if title is not None:
+            data["title"] = title
+        if description is not None:
+            data["description"] = description
+        if due_date is not None:
+            # GitHub expects ISO 8601 format with timezone (Z for UTC)
+            if due_date.tzinfo is None:
+                # Assume UTC for naive datetime
+                data["due_on"] = due_date.isoformat() + "Z"
+            else:
+                data["due_on"] = due_date.isoformat()
+        if state is not None:
+            data["state"] = state
+
+        response = self._make_request(
+            "PATCH",
+            f"/repos/{self.owner}/{self.repo}/milestones/{milestone_number}",
+            json=data,
+        )
+        return response.json()
+
+    def delete_milestone(self, milestone_number: int) -> None:
+        """Delete a milestone."""
+        self._check_repository()
+        self._make_request(
+            "DELETE", f"/repos/{self.owner}/{self.repo}/milestones/{milestone_number}"
+        )

roadmap/adapters/persistence/__init__.py

@@ -0,0 +1,35 @@
+"""Persistence Layer - Data Serialization and Storage.
+
+This layer handles reading and writing data to files, including:
+- YAML frontmatter parsing
+- File locking mechanisms
+- Enhanced persistence with backup/recovery
+- Database infrastructure management
+- File synchronization
+
+Modules:
+- database_manager.py: SQLite connection and schema management
+- file_synchronizer.py: File-to-database synchronization
+- parser.py: Issue/Milestone/Project YAML frontmatter parsing
+- persistence.py: Enhanced YAML validation and recovery
+- file_locking.py: File-based locking mechanism
+"""
+
+from .conflict_resolver import ConflictResolver
+from .database_manager import DatabaseManager
+from .file_synchronizer import FileSynchronizer
+from .parser import FrontmatterParser, IssueParser, MilestoneParser, ProjectParser
+from .persistence import enhanced_persistence
+from .sync_state_tracker import SyncStateTracker
+
+__all__ = [
+    "ConflictResolver",
+    "DatabaseManager",
+    "FileSynchronizer",
+    "FrontmatterParser",
+    "IssueParser",
+    "MilestoneParser",
+    "ProjectParser",
+    "SyncStateTracker",
+    "enhanced_persistence",
+]

roadmap/adapters/persistence/conflict_resolver.py

@@ -0,0 +1,190 @@
+"""Conflict detection and resolution for file synchronization.
+
+This module handles detection and management of conflicts that arise during
+file synchronization operations.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from roadmap.common.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class ConflictResolver:
+    """Handles detection and resolution of synchronization conflicts."""
+
+    def __init__(self, data_dir: Path):
+        """Initialize the conflict resolver.
+
+        Args:
+            data_dir: Root directory for data files
+        """
+        self.data_dir = data_dir
+
+    def detect_conflicts(self) -> list[str]:
+        """Detect files with git merge conflict markers.
+
+        Returns:
+            List of file paths containing conflict markers
+        """
+        conflict_files = []
+
+        try:
+            for file_path in self.data_dir.rglob("*.md"):
+                if self._has_conflict_markers(file_path):
+                    conflict_files.append(str(file_path))
+        except Exception as e:
+            logger.warning(
+                "error_detecting_conflicts",
+                error=str(e),
+                severity="operational",
+            )
+
+        return conflict_files
+
+    def _has_conflict_markers(self, file_path: Path) -> bool:
+        """Check if a file contains git conflict markers.
+
+        Args:
+            file_path: Path to file to check
+
+        Returns:
+            True if file contains conflict markers
+        """
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                content = f.read()
+                # Check for standard git conflict markers
+                return (
+                    "<<<<<<< HEAD" in content
+                    or "<<<<<<<" in content
+                    or "=======" in content
+                    or ">>>>>>>" in content
+                )
+        except Exception as e:
+            logger.debug("conflict_marker_check_failed", error=str(e))
+            return False
+
+    def resolve_conflict(self, file_path: Path, resolution: str) -> bool:
+        """Resolve a file conflict by removing markers.
+
+        Args:
+            file_path: Path to file with conflict
+            resolution: Which version to keep - "ours" or "theirs"
+
+        Returns:
+            True if resolution was successful
+        """
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                content = f.read()
+
+            # Remove conflict markers and keep appropriate version
+            resolved = self._remove_conflict_markers(content, resolution)
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(resolved)
+
+            logger.info(
+                "conflict_resolved",
+                filepath=file_path.name,
+                resolution=resolution,
+            )
+            return True
+        except Exception as e:
+            logger.error(
+                "error_resolving_conflict",
+                file_path=str(file_path),
+                error=str(e),
+                severity="operational",
+            )
+            return False
+
+    def _remove_conflict_markers(self, content: str, resolution: str) -> str:
+        """Remove conflict markers from content, keeping specified version.
+
+        Args:
+            content: File content with conflict markers
+            resolution: Which version to keep - "ours" or "theirs"
+
+        Returns:
+            Content with conflict markers removed
+        """
+        lines = content.split("\n")
+        resolved_lines = []
+        in_conflict = False
+        ours_section = []
+        theirs_section = []
+        current_section = None
+
+        for line in lines:
+            if line.startswith("<<<<<<< HEAD"):
+                in_conflict = True
+                current_section = "ours"
+                ours_section = []
+                theirs_section = []
+            elif line.startswith("======="):
+                if in_conflict:
+                    current_section = "theirs"
+            elif line.startswith(">>>>>>>"):
+                in_conflict = False
+                if resolution == "ours":
+                    resolved_lines.extend(ours_section)
+                else:
+                    resolved_lines.extend(theirs_section)
+                ours_section = []
+                theirs_section = []
+            elif in_conflict:
+                if current_section == "ours":
+                    ours_section.append(line)
+                else:
+                    theirs_section.append(line)
+            else:
+                resolved_lines.append(line)
+
+        return "\n".join(resolved_lines)
+
+    def auto_resolve_conflicts(
+        self, sync_state_tracker, resolution: str = "ours"
+    ) -> bool:
+        """Automatically resolve all detected conflicts.
+
+        Args:
+            sync_state_tracker: SyncStateTracker instance for updating state
+            resolution: Which version to keep for all conflicts
+
+        Returns:
+            True if all conflicts resolved successfully
+        """
+        conflict_files = self.detect_conflicts()
+
+        if not conflict_files:
+            return True
+
+        all_resolved = True
+        for file_path in conflict_files:
+            if not self.resolve_conflict(Path(file_path), resolution):
+                all_resolved = False
+
+        if all_resolved:
+            sync_state_tracker.clear_conflicts()
+        else:
+            sync_state_tracker.mark_conflicts_detected(conflict_files)
+
+        return all_resolved
+
+    def get_conflict_summary(self) -> dict[str, Any]:
+        """Get summary of detected conflicts.
+
+        Returns:
+            Dictionary with conflict information
+        """
+        conflict_files = self.detect_conflicts()
+
+        return {
+            "has_conflicts": len(conflict_files) > 0,
+            "conflict_count": len(conflict_files),
+            "files": conflict_files,
+        }