roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/sync/services/remote_issue_creation_service.py

@@ -0,0 +1,112 @@
+"""Service for creating local issues from remote data."""
+
+from structlog import get_logger
+
+from roadmap.core.domain.issue import Issue, Status
+from roadmap.core.models.sync_models import SyncIssue
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = get_logger()
+
+
+class RemoteIssueCreationService:
+    """Handles creating local issues from remote issue data."""
+
+    def __init__(self, core: RoadmapCore):
+        """Initialize creation service.
+
+        Args:
+            core: RoadmapCore instance
+        """
+        self.core = core
+
+    def create_issue_from_remote(
+        self, remote_id: str | int, remote_issue: SyncIssue
+    ) -> Issue:
+        """Create a local Issue from remote SyncIssue data.
+
+        Extracts relevant fields from remote issue and creates a local Issue object.
+        Adds "synced:from-github" label to mark as synced from remote.
+        Uses remote milestone if available, otherwise defaults to backlog.
+
+        Args:
+            remote_id: Remote issue ID (number)
+            remote_issue: SyncIssue object with remote data including:
+                - title: Issue title
+                - headline: Short description
+                - status: 'open', 'closed', etc.
+                - labels: List of label names
+                - assignee: Assignee login
+                - milestone: Milestone title or None
+                - backend_id: GitHub issue number
+
+        Returns:
+            New Issue object ready to be created
+        """
+        try:
+            # Normalize status
+            issue_status = self._normalize_status(remote_issue.status)
+
+            # Prepare labels with synced marker
+            labels = list(remote_issue.labels or [])
+            if "synced:from-github" not in labels:
+                labels.append("synced:from-github")
+
+            # Create the issue
+            new_issue = Issue(
+                title=remote_issue.title or f"Remote Issue {remote_id}",
+                content=remote_issue.headline or "",
+                status=issue_status,
+                labels=labels,
+                assignee=remote_issue.assignee,
+                milestone=remote_issue.milestone or "backlog",
+            )
+
+            # Link to remote
+            if remote_issue.backend_id:
+                new_issue.remote_ids["github"] = remote_issue.backend_id
+
+            logger.info(
+                "remote_issue_created_locally",
+                remote_id=remote_id,
+                title=remote_issue.title,
+                local_status=issue_status,
+            )
+
+            return new_issue
+
+        except Exception as e:
+            logger.error(
+                "remote_issue_creation_failed",
+                remote_id=remote_id,
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+            raise
+
+    @staticmethod
+    def _normalize_status(remote_status: str | None) -> Status:
+        """Normalize remote status to local Status enum.
+
+        Args:
+            remote_status: Remote status string (e.g., 'open', 'closed')
+
+        Returns:
+            Local Status enum value
+        """
+        if not remote_status:
+            return Status.TODO
+
+        remote_lower = remote_status.lower()
+
+        # Map common remote statuses to local statuses
+        status_map = {
+            "open": Status.TODO,
+            "in_progress": Status.IN_PROGRESS,
+            "in progress": Status.IN_PROGRESS,
+            "done": Status.CLOSED,
+            "closed": Status.CLOSED,
+            "blocked": Status.BLOCKED,
+        }
+
+        return status_map.get(remote_lower, Status.TODO)

roadmap/adapters/sync/services/sync_analysis_service.py

@@ -0,0 +1,250 @@
+"""Service for analyzing and classifying sync changes."""
+
+from datetime import UTC, datetime
+
+from structlog import get_logger
+
+from roadmap.core.services.sync.sync_key_normalizer import normalize_remote_keys
+from roadmap.core.services.sync.sync_state import IssueBaseState, SyncState
+from roadmap.core.services.sync.sync_state_comparator import SyncStateComparator
+from roadmap.core.services.sync.sync_state_manager import SyncStateManager
+
+logger = get_logger(__name__)
+
+
+class SyncAnalysisService:
+    """Handles change analysis and classification for sync operations."""
+
+    def __init__(
+        self,
+        state_comparator: SyncStateComparator,
+        state_manager: SyncStateManager,
+        core=None,
+    ):
+        """Initialize analysis service.
+
+        Args:
+            state_comparator: Service for detecting changes
+            state_manager: Service for managing baseline state
+            core: Optional RoadmapCore for database baseline fallback
+        """
+        self.state_comparator = state_comparator
+        self.state_manager = state_manager
+        self.core = core
+
+    def load_baseline_safe(self):
+        """Load baseline state but swallow errors and return None on failure.
+
+        Returns:
+            SyncState or None if not found
+        """
+        try:
+            logger.debug("loading_sync_state")
+            base_state = self.state_manager.load_sync_state_from_db()
+            if base_state:
+                logger.info(
+                    "previous_sync_state_loaded",
+                    base_issues_count=len(base_state.base_issues),
+                    last_sync=base_state.last_sync_time.isoformat()
+                    if base_state.last_sync_time
+                    else None,
+                )
+            else:
+                base_state = self._load_baseline_from_core()
+                if base_state:
+                    logger.info(
+                        "previous_sync_state_loaded",
+                        base_issues_count=len(base_state.base_issues),
+                        last_sync=base_state.last_sync_time.isoformat()
+                        if base_state.last_sync_time
+                        else None,
+                        source="core_db",
+                    )
+                else:
+                    logger.info(
+                        "no_previous_sync_state_found",
+                        reason="first_sync_or_state_cleared",
+                    )
+        except Exception:
+            logger.warning("sync_state_load_warning", reason="will_treat_as_first_sync")
+            base_state = None
+
+        return base_state
+
+    def _load_baseline_from_core(self) -> SyncState | None:
+        if not self.core or not getattr(self.core, "db", None):
+            return None
+
+        db_baseline = self.core.db.get_sync_baseline()
+        if not db_baseline:
+            return None
+
+        base_issues: dict[str, IssueBaseState] = {}
+        for issue_id, data in db_baseline.items():
+            base_issues[issue_id] = IssueBaseState(
+                id=issue_id,
+                status=data.get("status", "todo"),
+                title=data.get("title", ""),
+                assignee=data.get("assignee"),
+                headline=data.get("headline", ""),
+                content=data.get("content", ""),
+                labels=data.get("labels", []),
+            )
+
+        return SyncState(last_sync_time=datetime.now(UTC), base_issues=base_issues)
+
+    @staticmethod
+    def _is_empty_remote_value(value) -> bool:
+        if value is None:
+            return True
+        if isinstance(value, str):
+            return value.strip() == ""
+        if isinstance(value, (list, tuple, set, dict)):
+            return len(value) == 0
+        return False
+
+    @staticmethod
+    def _local_value_for_field(issue, field: str):
+        if issue is None:
+            return None
+        if field == "labels":
+            return issue.labels or []
+        if field == "assignee":
+            return issue.assignee
+        if field == "content":
+            return issue.content
+        return getattr(issue, field, None)
+
+    def _should_reclassify_as_push(self, change) -> bool:
+        if not change.remote_changes or not change.local_state:
+            return False
+        allowed_fields = {"labels", "assignee"}
+        for field, diff in change.remote_changes.items():
+            if field not in allowed_fields:
+                return False
+            remote_value = diff.get("to") if isinstance(diff, dict) else None
+            if not self._is_empty_remote_value(remote_value):
+                return False
+            local_value = self._local_value_for_field(change.local_state, field)
+            if self._is_empty_remote_value(local_value):
+                return False
+        return True
+
+    def _reclassify_remote_only_changes(self, remote_only_changes):
+        reclassified = [
+            c for c in remote_only_changes if self._should_reclassify_as_push(c)
+        ]
+        remaining = [c for c in remote_only_changes if c not in reclassified]
+        return reclassified, remaining
+
+    @staticmethod
+    def _extract_remote_id(remote_obj):
+        if isinstance(remote_obj, dict):
+            backend_id = remote_obj.get("backend_id") or remote_obj.get("number")
+            if backend_id is not None:
+                return str(backend_id)
+            remote_ids = remote_obj.get("remote_ids") or {}
+            backend_name = remote_obj.get("backend_name")
+            if backend_name and backend_name in remote_ids:
+                return str(remote_ids.get(backend_name))
+            if "github" in remote_ids:
+                return str(remote_ids.get("github"))
+            return None
+
+        backend_id = getattr(remote_obj, "backend_id", None)
+        if backend_id is not None:
+            return str(backend_id)
+        backend_name = getattr(remote_obj, "backend_name", None)
+        remote_ids = getattr(remote_obj, "remote_ids", None) or {}
+        if backend_name and backend_name in remote_ids:
+            return str(remote_ids.get(backend_name))
+        if "github" in remote_ids:
+            return str(remote_ids.get("github"))
+        return None
+
+    def _build_pull_ids(self, remote_only_changes, normalized_remote) -> list[str]:
+        pulls: list[str] = []
+        for change in remote_only_changes:
+            if change.issue_id in normalized_remote:
+                remote_obj = normalized_remote[change.issue_id]
+                remote_id = self._extract_remote_id(remote_obj)
+                if remote_id:
+                    pulls.append(remote_id)
+                    continue
+
+            issue_id = str(change.issue_id)
+            if issue_id.isdigit() or issue_id.startswith("_remote_"):
+                pulls.append(issue_id)
+            else:
+                logger.debug(
+                    "pull_id_unresolved",
+                    issue_id=change.issue_id,
+                    reason="no_remote_id",
+                )
+        return pulls
+
+    def analyze_and_classify(self, local_issues_dict, remote_issues_data, base_state):
+        """Run comparator and classify changes into categories.
+
+        Args:
+            local_issues_dict: Dict of local Issue objects (id -> Issue)
+            remote_issues_data: Dict of remote issue data (keyed by remote ID)
+            base_state: Previous sync state or None
+
+        Returns:
+            Tuple of (changes, conflicts, local_only_changes, remote_only_changes,
+                      no_changes, updates, pulls, up_to_date)
+        """
+        changes = self.state_comparator.analyze_three_way(
+            local_issues_dict,
+            remote_issues_data,
+            base_state.base_issues if base_state else None,
+        )
+
+        conflicts = [c for c in changes if c.has_conflict]
+        local_only_changes = [c for c in changes if c.is_local_only_change()]
+        remote_only_changes = [c for c in changes if c.is_remote_only_change()]
+        no_changes = [c for c in changes if c.conflict_type == "no_change"]
+
+        reclassified, remote_only_changes = self._reclassify_remote_only_changes(
+            remote_only_changes
+        )
+        if reclassified:
+            local_only_changes = local_only_changes + reclassified
+
+        updates = [c.local_state for c in local_only_changes if c.local_state]
+
+        normalized_remote = remote_issues_data
+        if self.state_comparator.backend is not None:
+            _, normalized_remote = normalize_remote_keys(
+                local_issues_dict,
+                remote_issues_data,
+                self.state_comparator.backend,
+                logger=logger,
+            )
+
+        # For pulls, we need to pass the remote ID (GitHub issue number) to pull_issues()
+        # Use normalized_remote so issue_id lookups match analysis keys.
+        pulls = self._build_pull_ids(remote_only_changes, normalized_remote)
+
+        up_to_date = [c.issue_id for c in no_changes]
+
+        logger.debug(
+            "three_way_analysis_complete",
+            total_changes=len(changes),
+            conflicts=len(conflicts),
+            local_only=len(local_only_changes),
+            remote_only=len(remote_only_changes),
+            no_change=len(no_changes),
+        )
+
+        return (
+            changes,
+            conflicts,
+            local_only_changes,
+            remote_only_changes,
+            no_changes,
+            updates,
+            pulls,
+            up_to_date,
+        )

roadmap/adapters/sync/services/sync_authentication_service.py

@@ -0,0 +1,57 @@
+"""Service for handling sync authentication with pluggable backends.
+
+Updated to use Result<T, SyncError> pattern for explicit error handling.
+"""
+
+from structlog import get_logger
+
+from roadmap.core.interfaces.sync_backend import SyncBackendInterface
+from roadmap.core.services.sync.sync_report import SyncReport
+
+logger = get_logger(__name__)
+
+
+class SyncAuthenticationService:
+    """Handles backend authentication for sync operations."""
+
+    def __init__(self, backend: SyncBackendInterface):
+        """Initialize authentication service.
+
+        Args:
+            backend: SyncBackendInterface implementation
+        """
+        self.backend = backend
+
+    def ensure_authenticated(self, report: SyncReport) -> bool:
+        """Ensure backend is authenticated.
+
+        Args:
+            report: SyncReport to record any authentication errors
+
+        Returns:
+            True if authenticated, False otherwise
+
+        Notes:
+            Handles Result<bool, SyncError> from backend.authenticate()
+        """
+        result = self.backend.authenticate()
+
+        if result.is_ok():
+            logger.info("backend_authenticated_successfully")
+            return True
+
+        # Handle authentication error
+        error = result.unwrap_err()
+        report.error = str(error)
+
+        logger.error(
+            "backend_authentication_failed",
+            operation="authenticate",
+            backend_type=type(self.backend).__name__,
+            error_type=error.error_type.value,
+            error_message=error.message,
+            is_recoverable=error.is_recoverable,
+            suggested_action=error.suggested_fix or "check_credentials",
+        )
+
+        return False

roadmap/adapters/sync/services/sync_data_fetch_service.py

@@ -0,0 +1,212 @@
+"""Service for fetching and counting sync data from local and remote sources.
+
+Updated to use Result<T, SyncError> pattern for explicit error handling.
+"""
+
+from structlog import get_logger
+
+from roadmap.core.interfaces.sync_backend import SyncBackendInterface
+from roadmap.core.services.sync.sync_report import SyncReport
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = get_logger(__name__)
+
+
+class SyncDataFetchService:
+    """Handles fetching issues and metadata from local and remote sources."""
+
+    def __init__(self, core: RoadmapCore, backend: SyncBackendInterface):
+        """Initialize data fetch service.
+
+        Args:
+            core: RoadmapCore instance
+            backend: SyncBackendInterface implementation
+        """
+        self.core = core
+        self.backend = backend
+
+    def fetch_remote_issues(self, report: SyncReport):
+        """Fetch remote issues from backend.
+
+        Args:
+            report: SyncReport to record any fetch errors
+
+        Returns:
+            Dict of remote issues or None if fetch failed
+
+        Notes:
+            Handles Result<dict, SyncError> from backend.get_issues()
+        """
+        logger.info("fetching_remote_issues_starting")
+
+        result = self.backend.get_issues()
+
+        if result.is_ok():
+            remote_issues_data = result.unwrap()
+
+            # Count by status
+            status_counts = {}
+            for issue in remote_issues_data.values():
+                status = getattr(issue, "state", None) or getattr(
+                    issue, "status", "unknown"
+                )
+                status = str(status)
+                status_counts[status] = status_counts.get(status, 0) + 1
+
+            logger.info(
+                "remote_issues_enumerated",
+                total_count=len(remote_issues_data),
+                status_breakdown=status_counts,
+            )
+            return remote_issues_data
+
+        # Handle fetch error
+        error = result.unwrap_err()
+        report.error = str(error)
+
+        logger.error(
+            "remote_issues_fetch_error",
+            operation="fetch_remote_issues",
+            error_type=error.error_type.value,
+            error_message=error.message,
+            is_recoverable=error.is_recoverable,
+            suggested_action=error.suggested_fix or "check_backend_connectivity",
+        )
+
+        return None
+
+    def fetch_local_issues(self, report: SyncReport):
+        """Fetch local issues from roadmap.
+
+        Args:
+            report: SyncReport to record any fetch errors
+
+        Returns:
+            List of local Issue objects or None if fetch failed
+        """
+        try:
+            logger.info(
+                "fetching_local_issues_starting",
+            )
+            local_issues = self.core.issues.list_all_including_archived() or []
+
+            # Count by status
+            status_counts = {}
+            for issue in local_issues:
+                status = str(issue.status)
+                status_counts[status] = status_counts.get(status, 0) + 1
+
+            logger.info(
+                "local_issues_enumerated",
+                total_count=len(local_issues),
+                status_breakdown=status_counts,
+            )
+            return local_issues
+        except OSError as e:
+            report.error = f"Failed to fetch local issues: {str(e)}"
+            logger.error(
+                "local_issues_fetch_error",
+                operation="fetch_local_issues",
+                error_type=type(e).__name__,
+                error=str(e),
+                is_recoverable=False,
+                suggested_action="check_file_permissions",
+            )
+            return None
+        except Exception as e:
+            report.error = f"Failed to fetch local issues: {str(e)}"
+            logger.error(
+                "local_issues_fetch_error",
+                operation="fetch_local_issues",
+                error_type=type(e).__name__,
+                error=str(e),
+                error_classification="sync_error",
+            )
+            return None
+
+    def count_active_archived(self, local_issues):
+        """Count active and archived issues.
+
+        Args:
+            local_issues: List of Issue objects
+
+        Returns:
+            Tuple of (active_count, archived_count)
+        """
+        active_issues_count = 0
+        archived_issues_count = 0
+        for issue in local_issues:
+            if issue.file_path and "archive" in issue.file_path:
+                archived_issues_count += 1
+            else:
+                active_issues_count += 1
+        return active_issues_count, archived_issues_count
+
+    def count_milestones(self):
+        """Count active and archived milestones.
+
+        Returns:
+            Tuple of (all_milestones, active_count, archived_count)
+        """
+        try:
+            all_milestones = self.core.milestones.list()
+            active_milestones_count = 0
+            archived_milestones_count = 0
+            for milestone in all_milestones:
+                if (
+                    hasattr(milestone, "file_path")
+                    and milestone.file_path
+                    and "archive" in milestone.file_path
+                ):
+                    archived_milestones_count += 1
+                else:
+                    active_milestones_count += 1
+            return all_milestones, active_milestones_count, archived_milestones_count
+        except Exception as e:
+            logger.debug("milestone_count_failed", error=str(e))
+            return [], 0, 0
+
+    def count_remote_stats(self, remote_issues_data):
+        """Count remote issues and milestones statistics.
+
+        Args:
+            remote_issues_data: Dict of remote issues
+
+        Returns:
+            Tuple of (total_count, open_count, closed_count, milestones_count)
+        """
+        try:
+            remote_issues_count = len(remote_issues_data) if remote_issues_data else 0
+            remote_open_count = 0
+            remote_closed_count = 0
+            for issue_data in remote_issues_data.values() if remote_issues_data else []:
+                state = getattr(issue_data, "state", None) or getattr(
+                    issue_data, "status", "open"
+                )
+                if state and state.lower() == "closed":
+                    remote_closed_count += 1
+                else:
+                    remote_open_count += 1
+
+            milestones_result = self.backend.get_milestones()
+            remote_milestones_count = (
+                len(milestones_result.unwrap()) if milestones_result.is_ok() else 0
+            )
+            logger.debug(
+                "remote_items_counted",
+                remote_issues=remote_issues_count,
+                remote_open=remote_open_count,
+                remote_closed=remote_closed_count,
+                remote_milestones=remote_milestones_count,
+            )
+            return (
+                remote_issues_count,
+                remote_open_count,
+                remote_closed_count,
+                remote_milestones_count,
+            )
+        except Exception as e:
+            logger.error(
+                "count_remote_stats_error", error=str(e), severity="operational"
+            )
+            return 0, 0, 0, 0