roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/sync/backends/services/github_issue_fetch_service.py

@@ -0,0 +1,158 @@
+"""Service for fetching issues from GitHub API."""
+
+from structlog import get_logger
+
+from roadmap.adapters.sync.backends.github_backend_helpers import GitHubBackendHelpers
+from roadmap.adapters.sync.backends.github_client import GitHubClientWrapper
+from roadmap.common.logging import log_error_with_context
+from roadmap.core.models.sync_models import SyncIssue
+
+logger = get_logger()
+
+
+class GitHubIssueFetchService:
+    """Handles fetching issues from GitHub API."""
+
+    def __init__(
+        self,
+        github_client: GitHubClientWrapper,
+        config: dict,
+        helpers: GitHubBackendHelpers,
+    ):
+        """Initialize fetch service.
+
+        Args:
+            github_client: GitHubClientWrapper for API access
+            config: Configuration dict with 'owner', 'repo'
+            helpers: GitHubBackendHelpers for conversions
+        """
+        self.github_client = github_client
+        self.config = config
+        self.helpers = helpers
+
+    def get_issues(self) -> dict[str, SyncIssue]:
+        """Fetch all remote issues from GitHub.
+
+        Returns:
+            Dict mapping remote issue IDs (as strings) to SyncIssue objects,
+            or empty dict if fetch fails.
+        """
+        if not self.github_client:
+            logger.warning("github_fetch_no_client")
+            return {}
+
+        owner = self.config.get("owner")
+        repo = self.config.get("repo")
+
+        if not owner or not repo:
+            logger.warning("github_fetch_missing_config", owner=owner, repo=repo)
+            return {}
+
+        try:
+            logger.debug(
+                "github_issue_fetch_start",
+                owner=owner,
+                repo=repo,
+            )
+            issues_data = self.github_client.get_issues(owner, repo, state="all")
+
+            logger.info(
+                "github_issues_fetched",
+                owner=owner,
+                repo=repo,
+                count=len(issues_data),
+            )
+
+            # Convert each GitHub issue to SyncIssue
+            result = {}
+            failed_conversions = 0
+            for issue_dict in issues_data:
+                try:
+                    sync_issue = self._dict_to_sync_issue(issue_dict)
+                    remote_id = str(issue_dict.get("number", ""))
+                    result[remote_id] = sync_issue
+                except Exception as e:
+                    failed_conversions += 1
+                    issue_number = (
+                        issue_dict.get("number")
+                        if isinstance(issue_dict, dict)
+                        else "unknown"
+                    )
+                    log_error_with_context(
+                        e,
+                        operation="convert_github_issue_to_sync",
+                        entity_type="Issue",
+                        entity_id=str(issue_number),
+                        additional_context={
+                            "owner": owner,
+                            "repo": repo,
+                            "total_issues": len(issues_data),
+                        },
+                        include_traceback=False,
+                    )
+            if failed_conversions > 0:
+                logger.warning(
+                    "github_issue_conversions_failed",
+                    owner=owner,
+                    repo=repo,
+                    total=len(issues_data),
+                    failed=failed_conversions,
+                    successful=len(result),
+                )
+            return result
+
+        except Exception as e:
+            log_error_with_context(
+                e,
+                operation="fetch_github_issues",
+                entity_type="Repository",
+                entity_id=f"{owner}/{repo}",
+                additional_context={"suggested_action": "check_connectivity"},
+                include_traceback=True,
+            )
+            return {}
+
+    @staticmethod
+    def _dict_to_sync_issue(issue_dict: dict) -> SyncIssue:
+        """Convert GitHub issue dict to SyncIssue object.
+
+        Args:
+            issue_dict: GitHub issue data from API
+
+        Returns:
+            SyncIssue with normalized data
+        """
+        if not issue_dict:
+            raise ValueError("Cannot convert None/empty issue dict to SyncIssue")
+
+        backend_id = issue_dict.get("number")
+        assignee_obj = issue_dict.get("assignee") or {}
+        milestone_obj = issue_dict.get("milestone") or {}
+
+        # Extract label names from label objects
+        labels_raw = issue_dict.get("labels", [])
+        label_names = []
+        if isinstance(labels_raw, list):
+            for label in labels_raw:
+                if isinstance(label, dict) and "name" in label:
+                    label_names.append(label["name"])
+                elif isinstance(label, str):
+                    label_names.append(label)
+
+        github_state = issue_dict.get("state")
+        status = "todo" if github_state == "open" else "closed"
+
+        return SyncIssue(
+            id=f"github-{backend_id}" if backend_id else "unknown",
+            title=issue_dict.get("title") or "Untitled",
+            headline=issue_dict.get("body") or "",
+            status=status,
+            labels=label_names,
+            assignee=assignee_obj.get("login")
+            if isinstance(assignee_obj, dict)
+            else None,
+            milestone=milestone_obj.get("title")
+            if isinstance(milestone_obj, dict)
+            else None,
+            backend_id=backend_id,
+        )

roadmap/adapters/sync/backends/services/github_label_sync_service.py

@@ -0,0 +1,126 @@
+"""GitHub label synchronization helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from structlog import get_logger
+
+logger = get_logger()
+
+
+class GitHubLabelSyncService:
+    """Encapsulates label capability checks, caching, and creation."""
+
+    def __init__(self, backend: Any):
+        """Initialize the label sync service for a backend instance."""
+        self.backend = backend
+        self.label_cache: set[str] | None = None
+        self.label_support: bool | None = None
+
+    def sync_labels_enabled(self) -> bool:
+        """Return whether label synchronization is enabled by configuration."""
+        config = getattr(self.backend, "config", {}) or {}
+        sync_settings = (
+            config.get("sync_settings", {}) if isinstance(config, dict) else {}
+        )
+        return bool(sync_settings.get("sync_labels", True))
+
+    @staticmethod
+    def get_label_color(name: str) -> str:
+        """Return the configured color hex value for a label name."""
+        label_colors = {
+            "priority:critical": "FF0000",
+            "priority:high": "FF9900",
+            "priority:medium": "FFFF00",
+            "priority:low": "00FF00",
+            "status:todo": "CCCCCC",
+            "status:in-progress": "0366D6",
+            "status:blocked": "D73A49",
+            "status:review": "A371F7",
+            "status:done": "28A745",
+        }
+        return label_colors.get(name, "CCCCCC")
+
+    def get_label_client(self):
+        """Return a label API client, or None when unsupported."""
+        if self.label_support is False:
+            return None
+
+        client = (
+            self.backend.get_label_client()
+            if hasattr(self.backend, "get_label_client")
+            else self.backend.get_api_client()
+        )
+
+        if client is None:
+            self.label_support = False
+            return None
+
+        if self.label_support is None:
+            if not (hasattr(client, "get_labels") and hasattr(client, "create_label")):
+                logger.warning(
+                    "github_label_client_missing_methods",
+                    has_get_labels=hasattr(client, "get_labels"),
+                    has_create_label=hasattr(client, "create_label"),
+                    severity="operational",
+                )
+                self.label_support = False
+                return None
+            self.label_support = True
+
+        return client
+
+    def init_label_cache(self, client) -> bool:
+        """Populate local label cache from GitHub."""
+        if self.label_cache is not None:
+            return True
+
+        try:
+            existing_labels = client.get_labels()
+            self.label_cache = {
+                label["name"]
+                for label in existing_labels
+                if isinstance(label, dict) and label.get("name")
+            }
+            return True
+        except Exception as e:
+            logger.warning(
+                "github_labels_fetch_failed",
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="operational",
+            )
+            self.label_cache = set()
+            return False
+
+    def ensure_labels_exist(self, labels: list[str]) -> None:
+        """Create any missing labels on GitHub when label sync is enabled."""
+        if not labels or not self.sync_labels_enabled():
+            return
+
+        client = self.get_label_client()
+        if client is None:
+            return
+
+        if not self.init_label_cache(client):
+            return
+
+        label_cache = self.label_cache
+        if label_cache is None:
+            return
+
+        missing = [label for label in labels if label not in label_cache]
+        for label in missing:
+            try:
+                client.create_label(label, self.get_label_color(label))
+                label_cache.add(label)
+                logger.info("github_label_created", label=label)
+            except Exception as e:
+                logger.warning(
+                    "github_label_create_failed",
+                    label=label,
+                    error=str(e),
+                    error_type=type(e).__name__,
+                    severity="operational",
+                )

roadmap/adapters/sync/backends/services/github_local_issue_sync_service.py

@@ -0,0 +1,229 @@
+"""Local issue persistence and remote-link synchronization helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from structlog import get_logger
+
+logger = get_logger()
+
+
+class GitHubLocalIssueSyncService:
+    """Handles local DB persistence and GitHub remote-link associations."""
+
+    def __init__(self, backend: Any):
+        """Initialize the local issue sync service for a backend instance."""
+        self.backend = backend
+
+    def persist_issue_before_linking(self, issue: Any, issue_id: str) -> bool:
+        """Persist issue to database before linking to GitHub."""
+        if not hasattr(self.backend, "core") or not self.backend.core:
+            return True
+
+        try:
+            issue_repo = self.backend.core.db.get_issue_repository()
+            existing = issue_repo.get(issue_id)
+
+            if not existing:
+                issue_data = {
+                    "id": issue_id,
+                    "title": issue.title,
+                    "headline": getattr(issue, "headline", ""),
+                    "description": issue.content or "",
+                    "status": str(issue.status),
+                    "priority": str(issue.priority),
+                    "issue_type": str(issue.type) if hasattr(issue, "type") else "task",
+                    "assignee": issue.assignee,
+                    "estimate_hours": issue.estimated_hours
+                    if hasattr(issue, "estimated_hours")
+                    else None,
+                    "due_date": None,
+                    "project_id": None,
+                }
+                issue_repo.create(issue_data)
+                logger.info(
+                    "persisted_issue_for_linking",
+                    issue_id=issue_id,
+                    title=issue.title,
+                )
+        except Exception as e:
+            logger.warning(
+                "failed_to_persist_issue_before_linking",
+                issue_id=issue_id,
+                error=str(e),
+                severity="operational",
+            )
+
+        return True
+
+    def link_issue_to_github(
+        self, issue_uuid: str, github_number: int
+    ) -> tuple[bool, str | None]:
+        """Link issue to GitHub in database."""
+        if not hasattr(self.backend, "core") or not self.backend.core:
+            return True, None
+
+        try:
+            self.backend.core.db.remote_links.link_issue(
+                issue_uuid=issue_uuid,
+                backend_name="github",
+                remote_id=str(github_number),
+            )
+            logger.info(
+                "github_issue_linked",
+                issue_id=issue_uuid,
+                github_number=github_number,
+            )
+            return True, None
+        except Exception as e:
+            logger.warning(
+                "github_issue_link_failed",
+                issue_id=issue_uuid,
+                github_number=github_number,
+                error=str(e),
+                severity="operational",
+            )
+            return False, str(e)
+
+    def get_project_id_for_synced_issue(self) -> str | None:
+        """Get default project ID for synced issues."""
+        if not hasattr(self.backend, "core") or not self.backend.core:
+            return None
+
+        try:
+            projects = list(self.backend.core.projects.list())
+            return projects[0].id if projects else None
+        except Exception as e:
+            logger.warning(
+                "failed_to_get_projects_for_issue",
+                error=str(e),
+                severity="operational",
+            )
+            return None
+
+    def resolve_local_issue_id(
+        self, github_id: str | int | None, local_issue: Any
+    ) -> str:
+        """Resolve local issue ID from remote link mapping when available."""
+        if github_id is None:
+            return local_issue.id
+
+        if not hasattr(self.backend, "core") or not self.backend.core:
+            return local_issue.id
+
+        try:
+            issue_uuid = self.backend.core.db.remote_links.get_issue_uuid(
+                backend_name="github", remote_id=github_id
+            )
+            if issue_uuid:
+                return issue_uuid
+        except Exception as e:
+            logger.warning(
+                "github_remote_link_lookup_failed",
+                github_number=github_id,
+                error=str(e),
+                severity="operational",
+            )
+
+        return local_issue.id
+
+    def create_or_update_issue_locally(
+        self, sync_issue: Any, local_issue: Any, github_id: str | int | None
+    ) -> str | None:
+        """Create or update issue in local database."""
+        if not hasattr(self.backend, "core") or not self.backend.core:
+            return local_issue.id
+
+        issue_repo = self.backend.core.db.get_issue_repository()
+        local_issue_id = self.resolve_local_issue_id(github_id, local_issue)
+        existing = issue_repo.get(local_issue_id)
+        project_id = (
+            existing.get("project_id")
+            if existing
+            else self.get_project_id_for_synced_issue()
+        )
+
+        if existing:
+            updates = {
+                "title": local_issue.title,
+                "headline": local_issue.headline,
+                "description": local_issue.content or "",
+                "status": str(local_issue.status),
+                "priority": str(local_issue.priority),
+                "issue_type": str(local_issue.issue_type),
+                "assignee": local_issue.assignee,
+                "estimate_hours": local_issue.estimated_hours,
+                "due_date": None,
+            }
+            if project_id:
+                updates["project_id"] = project_id
+
+            issue_repo.update(local_issue_id, updates)
+            logger.info(
+                "github_issue_updated_locally",
+                issue_id=local_issue_id,
+                github_number=github_id,
+                title=local_issue.title,
+            )
+        else:
+            issue_data = {
+                "id": local_issue_id,
+                "title": local_issue.title,
+                "headline": local_issue.headline,
+                "description": local_issue.content or "",
+                "status": str(local_issue.status),
+                "priority": str(local_issue.priority),
+                "issue_type": str(local_issue.issue_type),
+                "project_id": project_id,
+                "assignee": local_issue.assignee,
+                "estimate_hours": local_issue.estimated_hours,
+                "due_date": None,
+            }
+            issue_repo.create(issue_data)
+            logger.info(
+                "github_issue_created_locally",
+                issue_id=local_issue_id,
+                github_number=github_id,
+                title=local_issue.title,
+            )
+
+        return local_issue_id
+
+    def link_pulled_issue_locally(
+        self, local_issue_id: str | None, github_id: str | int | None
+    ) -> bool:
+        """Link pulled issue to GitHub in local database."""
+        if not hasattr(self.backend, "core") or not self.backend.core:
+            return True
+
+        if not local_issue_id or github_id is None:
+            logger.warning(
+                "github_issue_link_skipped_missing_ids",
+                issue_id=local_issue_id,
+                github_number=github_id,
+                severity="data_error",
+            )
+            return True
+
+        try:
+            self.backend.core.db.remote_links.link_issue(
+                issue_uuid=local_issue_id,
+                backend_name="github",
+                remote_id=str(github_id),
+            )
+            logger.info(
+                "github_issue_linked_locally",
+                issue_id=local_issue_id,
+                github_number=github_id,
+            )
+            return True
+        except Exception as e:
+            logger.warning(
+                "github_issue_link_failed",
+                issue_id=local_issue_id,
+                github_number=github_id,
+                error=str(e),
+                severity="operational",
+            )
+            return True