roadmap-cli 0.1.1__py3-none-any.whl

roadmap/core/services/github/github_change_detector.py

@@ -0,0 +1,162 @@
+"""Detects changes for GitHub linked entities."""
+
+from datetime import datetime
+from typing import Any
+
+from roadmap.core.domain import Issue
+from roadmap.core.services.github.github_issue_client import GitHubIssueClient
+from roadmap.core.services.sync.sync_report import IssueChange
+
+
+class GitHubChangeDetector:
+    """Detects what has changed for GitHub-linked entities."""
+
+    def __init__(self, github_client: GitHubIssueClient):
+        """Initialize detector with GitHub client.
+
+        Args:
+            github_client: Client for fetching GitHub issues
+        """
+        self.github_client = github_client
+
+    def detect_issue_changes(
+        self,
+        local_issue: Issue,
+        owner: str,
+        repo: str,
+        last_sync_time: datetime | None = None,
+    ) -> IssueChange:
+        """Detect changes for a single linked issue.
+
+        Args:
+            local_issue: Local issue to check
+            owner: GitHub repository owner
+            repo: GitHub repository name
+            last_sync_time: When the issue was last synced
+
+        Returns:
+            IssueChange with detected changes
+        """
+        change = IssueChange(
+            issue_id=local_issue.id,
+            title=local_issue.title,
+            last_sync_time=last_sync_time,
+        )
+
+        try:
+            if not owner or not repo:
+                change.github_changes = {
+                    "error": "GitHub config incomplete (owner/repo required)"
+                }
+                return change
+
+            if not local_issue.github_issue:
+                change.github_changes = {"error": "Issue not linked to GitHub"}
+                return change
+
+            # Fetch GitHub issue
+            github_issue_number = self._parse_github_issue_number(
+                local_issue.github_issue
+            )
+            github_issue = self.github_client.fetch_issue(
+                owner, repo, github_issue_number
+            )
+
+            if not github_issue:
+                change.github_changes = {"issue": "deleted on GitHub"}
+                return change
+
+            # Detect local and GitHub changes
+            change.local_changes = self._detect_local_changes(local_issue)
+            change.github_changes = self._detect_github_changes(
+                local_issue, github_issue
+            )
+
+            # Determine conflict status
+            if change.local_changes and change.github_changes:
+                change.has_conflict = True
+
+        except Exception as e:
+            change.github_changes = {"error": str(e)}
+
+        return change
+
+    def detect_milestone_changes(self, _local_milestone: Any) -> IssueChange | None:
+        """Detect changes for a milestone.
+
+        Args:
+            _local_milestone: Local milestone to check
+
+        Returns:
+            IssueChange with detected changes, or None if no changes
+        """
+        # Placeholder: Milestone detection logic to be extracted
+        # from _detect_milestone_changes
+        return None
+
+    @staticmethod
+    def _parse_github_issue_number(github_issue: Any) -> int:
+        """Parse GitHub issue number from string or int.
+
+        Args:
+            github_issue: GitHub issue number (string or int)
+
+        Returns:
+            GitHub issue number as integer
+
+        Raises:
+            ValueError: If cannot parse issue number
+        """
+        if isinstance(github_issue, str):
+            return int(github_issue)
+        return github_issue
+
+    @staticmethod
+    def _detect_local_changes(_issue: Issue) -> dict[str, Any]:
+        """Detect changes made locally to the issue.
+
+        Args:
+            _issue: Issue to check
+
+        Returns:
+            Dict of detected local changes
+        """
+        changes = {}
+
+        # Check for local modifications
+        # (Placeholder - extract from _detect_local_changes)
+        # Note: Issue model doesn't track dirty state, so no local changes detected here
+        # This is a placeholder for future enhancement when tracking changes
+
+        return changes
+
+    @staticmethod
+    def _detect_github_changes(
+        local_issue: Issue, github_issue: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Detect changes made on GitHub.
+
+        Args:
+            local_issue: Local issue version
+            github_issue: GitHub issue version
+
+        Returns:
+            Dict of detected GitHub changes
+        """
+        changes = {}
+
+        # Compare title
+        if github_issue.get("title") != local_issue.title:
+            changes["title"] = github_issue.get("title")
+
+        # Compare content
+        gh_body = github_issue.get("body", "")
+        if gh_body != (local_issue.content or ""):
+            changes["content"] = gh_body
+
+        # Compare status
+        gh_status = "closed" if github_issue.get("state") == "closed" else "open"
+        if gh_status != local_issue.status:
+            changes["status"] = gh_status
+
+        return changes

roadmap/core/services/github/github_config_validator.py

@@ -0,0 +1,148 @@
+"""GitHub configuration validation service."""
+
+from pathlib import Path
+
+import requests
+
+from roadmap.core.services.github.github_integration_service import (
+    GitHubIntegrationService,
+)
+
+
+class GitHubConfigValidator:
+    """Validates GitHub configuration before operations."""
+
+    def __init__(self, config_path: Path):
+        """Initialize validator with config path.
+
+        Args:
+            config_path: Path to .roadmap directory
+        """
+        self.config_path = config_path
+        self.config_file = config_path / "config.yaml"
+        self.service = GitHubIntegrationService(config_path, self.config_file)
+
+    def validate_config(self) -> tuple[bool, str | None]:
+        """Validate GitHub configuration.
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        # Check if config exists
+        token, _, repo = self.service.get_github_config()
+        if not token or not repo:
+            return (
+                False,
+                "GitHub not configured. Run: roadmap init --github-repo owner/repo --github-token <token>",
+            )
+
+        # Check required fields
+        if not repo:
+            return False, "GitHub repo not configured in config.yaml"
+
+        if not token:
+            return False, "GitHub token not configured in config.yaml"
+
+        # Validate token format (basic check)
+        if not isinstance(token, str) or len(token) < 10:
+            return False, "GitHub token appears invalid (too short)"
+
+        return True, None
+
+    def validate_token(self) -> tuple[bool, str | None]:
+        """Validate GitHub token accessibility.
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        token, _, _ = self.service.get_github_config()
+        if not token:
+            return False, "GitHub token not set"
+
+        try:
+            # Test token by making a simple API call
+            headers = {
+                "Authorization": f"token {token}",
+                "Accept": "application/vnd.github.v3+json",
+            }
+            response = requests.get(
+                "https://api.github.com/user",
+                headers=headers,
+                timeout=5,
+            )
+
+            if response.status_code == 401:
+                return False, "GitHub token is invalid or expired"
+            elif response.status_code == 403:
+                return False, "GitHub token has insufficient permissions"
+            elif response.status_code == 200:
+                return True, None
+            else:
+                return (
+                    False,
+                    f"GitHub API error: {response.status_code}",
+                )
+        except requests.RequestException as e:
+            return False, f"Failed to reach GitHub: {str(e)}"
+        except Exception as e:
+            return False, f"Unexpected error validating token: {str(e)}"
+
+    def validate_repo_access(self) -> tuple[bool, str | None]:
+        """Validate access to configured repository.
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        token, _, repo = self.service.get_github_config()
+        if not token or not repo:
+            return False, "GitHub config incomplete"
+
+        try:
+            # Test repo access
+            headers = {
+                "Authorization": f"token {token}",
+                "Accept": "application/vnd.github.v3+json",
+            }
+            url = f"https://api.github.com/repos/{repo}"
+            response = requests.get(url, headers=headers, timeout=5)
+
+            if response.status_code == 401:
+                return False, "GitHub token is invalid or expired"
+            elif response.status_code == 403:
+                return False, f"Access denied to repository {repo}"
+            elif response.status_code == 404:
+                return False, f"Repository not found: {repo}"
+            elif response.status_code == 200:
+                return True, None
+            else:
+                return (
+                    False,
+                    f"GitHub API error: {response.status_code}",
+                )
+        except requests.RequestException as e:
+            return False, f"Failed to reach GitHub: {str(e)}"
+        except Exception as e:
+            return False, f"Unexpected error validating repo: {str(e)}"
+
+    def validate_all(self) -> tuple[bool, str | None]:
+        """Run all validations.
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        # Config validation
+        is_valid, error = self.validate_config()
+        if not is_valid:
+            return False, error
+
+        # Token validation
+        is_valid, error = self.validate_token()
+        if not is_valid:
+            return False, error
+
+        # Repo access validation
+        is_valid, error = self.validate_repo_access()
+        if not is_valid:
+            return False, error
+
+        return True, None

roadmap/core/services/github/github_conflict_detector.py

@@ -0,0 +1,179 @@
+"""GitHub conflict detection service."""
+
+from datetime import datetime
+from typing import Any
+
+from roadmap.common.datetime_parser import UnifiedDateTimeParser
+from roadmap.core.domain.issue import Issue
+from roadmap.core.services.github.github_integration_service import (
+    GitHubIntegrationService,
+)
+from roadmap.core.services.github.github_issue_client import GitHubIssueClient
+
+
+class GitHubConflictDetector:
+    """Detects conflicts between local and GitHub issues."""
+
+    def __init__(self, integration_service: GitHubIntegrationService):
+        """Initialize conflict detector.
+
+        Args:
+            integration_service: GitHub integration service instance
+        """
+        self.service = integration_service
+        token, owner, repo = integration_service.get_github_config()
+        self.owner = owner
+        self.repo = repo
+        self.client = GitHubIssueClient(token)
+
+    def detect_conflicts(
+        self, local_issue: Issue, github_number: int
+    ) -> dict[str, Any]:
+        """Detect conflicts between local and GitHub versions.
+
+        Args:
+            local_issue: Local issue entity
+            github_number: GitHub issue number
+
+        Returns:
+            Dict with conflict information:
+            {
+                'has_conflicts': bool,
+                'local_modified': bool,
+                'github_modified': bool,
+                'last_sync': datetime | None,
+                'warnings': List[str]
+            }
+        """
+        conflicts = {
+            "has_conflicts": False,
+            "local_modified": False,
+            "github_modified": False,
+            "last_sync": None,
+            "warnings": [],
+        }
+
+        # Get last sync time from issue metadata if available
+        last_sync = self._get_last_sync_time(local_issue)
+        conflicts["last_sync"] = last_sync
+
+        # If no last sync recorded, can't detect conflicts
+        if not last_sync:
+            conflicts["warnings"].append(
+                "No sync history available. First sync will update all fields."
+            )
+            return conflicts
+
+        # Check if we have required GitHub config
+        if not self.owner or not self.repo:
+            conflicts["warnings"].append(
+                "GitHub configuration missing. Cannot check for GitHub changes."
+            )
+            return conflicts
+
+        # Check if GitHub issue was modified after last sync
+        try:
+            github_issue = self.client.fetch_issue(self.owner, self.repo, github_number)
+            github_updated_at = self._parse_github_timestamp(
+                github_issue.get("updated_at")
+            )
+
+            if github_updated_at and github_updated_at > last_sync:
+                conflicts["github_modified"] = True
+                conflicts["warnings"].append(
+                    "GitHub issue was modified after last sync"
+                )
+        except Exception as e:
+            conflicts["warnings"].append(
+                f"Could not check GitHub for changes: {str(e)}"
+            )
+
+        # Check if local issue was modified after last sync
+        if self._is_local_modified_after_sync(local_issue, last_sync):
+            conflicts["local_modified"] = True
+            conflicts["warnings"].append("Local issue was modified after last sync")
+
+        # Set has_conflicts flag if both were modified
+        if conflicts["local_modified"] and conflicts["github_modified"]:
+            conflicts["has_conflicts"] = True
+            conflicts["warnings"].append(
+                "⚠️  Both local and GitHub versions have changes. Review carefully before syncing."
+            )
+
+        return conflicts
+
+    def _get_last_sync_time(self, issue: Issue) -> datetime | None:
+        """Get last sync timestamp from issue.
+
+        Args:
+            issue: Issue entity
+
+        Returns:
+            Last sync datetime or None
+        """
+        # Check if issue has sync metadata with sync timestamp
+        if (
+            issue.github_sync_metadata
+            and "sync_timestamp" in issue.github_sync_metadata
+        ):
+            return issue.github_sync_metadata["sync_timestamp"]
+
+        # Check issue updated_at as fallback
+        if issue.updated:
+            return issue.updated
+
+        return None
+
+    def _is_local_modified_after_sync(self, issue: Issue, last_sync: datetime) -> bool:
+        """Check if local issue was modified after sync time.
+
+        Args:
+            issue: Issue entity
+            last_sync: Last sync timestamp
+
+        Returns:
+            True if modified after sync
+        """
+        if not issue.updated:
+            return False
+
+        updated_at = issue.updated
+        return updated_at > last_sync
+
+    def _parse_github_timestamp(self, timestamp: str | None) -> datetime | None:
+        """Parse GitHub API timestamp.
+
+        Args:
+            timestamp: GitHub timestamp string
+
+        Returns:
+            Parsed datetime or None
+        """
+        if not timestamp:
+            return None
+
+        try:
+            return UnifiedDateTimeParser.parse_github_timestamp(timestamp)
+        except (ValueError, AttributeError):
+            return None
+
+    def get_conflict_summary(self, conflicts: dict[str, Any]) -> str:
+        """Get human-readable conflict summary.
+
+        Args:
+            conflicts: Conflicts dict from detect_conflicts()
+
+        Returns:
+            Summary string
+        """
+        if not conflicts["warnings"]:
+            return "No conflicts detected. Safe to sync."
+
+        summary = "Conflict Detection Summary:\n"
+        for warning in conflicts["warnings"]:
+            summary += f"  • {warning}\n"
+
+        if conflicts["has_conflicts"]:
+            summary += "\nRecommendation: Review changes manually before syncing."
+
+        return summary

roadmap/core/services/github/github_entity_classifier.py

@@ -0,0 +1,51 @@
+"""Classifies GitHub entities (active/archived)."""
+
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+
+
+class GitHubEntityClassifier:
+    """Separates entities into active and archived categories."""
+
+    @staticmethod
+    def classify_entity_state(entity: Any) -> bool:
+        """Determine if entity is archived.
+
+        Args:
+            entity: Entity object to check
+
+        Returns:
+            True if archived, False if active
+
+        Note:
+            Handles mocks safely by checking isinstance
+        """
+        is_archived = False
+        if hasattr(entity, "archived"):
+            archived_attr = getattr(entity, "archived", False)
+            # Check if it's an actual boolean value, not a mock
+            if isinstance(archived_attr, bool):
+                is_archived = archived_attr
+        return is_archived
+
+    @classmethod
+    def separate_by_state(cls, entities: list[T]) -> tuple[list[T], list[T]]:
+        """Separate entities into active and archived.
+
+        Args:
+            entities: List of entities to classify
+
+        Returns:
+            Tuple of (active_entities, archived_entities)
+        """
+        active = []
+        archived = []
+
+        for entity in entities:
+            if cls.classify_entity_state(entity):
+                archived.append(entity)
+            else:
+                active.append(entity)
+
+        return active, archived