roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/git/workflow_automation.py

@@ -0,0 +1,286 @@
+"""High-level workflow automation for Git integration."""
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from structlog import get_logger
+
+from roadmap.adapters.persistence.parser import IssueParser
+from roadmap.core.domain import Issue, Status
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+from .git import GitCommit, GitIntegration
+from .git_hooks_manager import GitHookManager
+
+logger = get_logger()
+
+
+class WorkflowAutomation:
+    """High-level workflow automation orchestrator."""
+
+    def __init__(self, roadmap_core: RoadmapCore):
+        """Initialize WorkflowAutomation.
+
+        Args:
+            roadmap_core: Core roadmap integration instance.
+        """
+        self.core = roadmap_core
+        self.hook_manager = GitHookManager(roadmap_core)
+        self.git_integration = GitIntegration()
+
+    def setup_automation(self, features: list[str] | None = None) -> dict[str, bool]:
+        """Set up automated workflow features.
+
+        Args:
+            features: List of features to enable. Options:
+                     ['git-hooks', 'status-automation', 'progress-tracking']
+
+        Returns:
+            Dict mapping feature names to success status.
+        """
+        all_features = ["git-hooks", "status-automation", "progress-tracking"]
+        features_to_enable = features or all_features
+
+        results = {}
+
+        if "git-hooks" in features_to_enable:
+            results["git-hooks"] = self.hook_manager.install_hooks()
+
+        if "status-automation" in features_to_enable:
+            results["status-automation"] = self._setup_status_automation()
+
+        if "progress-tracking" in features_to_enable:
+            results["progress-tracking"] = self._setup_progress_tracking()
+
+        return results
+
+    def disable_automation(self) -> bool:
+        """Disable all workflow automation."""
+        try:
+            # Remove Git hooks
+            self.hook_manager.uninstall_hooks()
+
+            # Clean up context files
+            context_files = [
+                ".roadmap_branch_context.json",
+                ".roadmap_automation_config.json",
+                ".roadmap_progress_tracking.json",
+            ]
+
+            for file_path in context_files:
+                if Path(file_path).exists():
+                    Path(file_path).unlink()
+
+            return True
+
+        except Exception as e:
+            logger.error(
+                "context_cleanup_failed", error=str(e), severity="system_error"
+            )
+            return False
+
+    def _setup_status_automation(self) -> bool:
+        """Set up intelligent status automation rules."""
+        try:
+            # Create automation config
+            config = {
+                "status_rules": {
+                    "auto_in_progress": True,  # Move to in-progress on first commit
+                    "auto_done_on_close": True,  # Mark done on "closes" commit
+                    "auto_blocked_detection": True,  # Detect blocked status from patterns
+                },
+                "progress_rules": {
+                    "commit_based_progress": True,  # Update progress from commits
+                    "milestone_auto_complete": True,  # Auto-complete milestones
+                    "velocity_tracking": True,  # Track team velocity
+                },
+            }
+
+            config_file = Path(".roadmap_automation_config.json")
+            config_file.write_text(json.dumps(config, indent=2))
+            return True
+
+        except Exception as e:
+            logger.error(
+                "status_automation_setup_failed", error=str(e), severity="system_error"
+            )
+            return False
+
+    def _setup_progress_tracking(self) -> bool:
+        """Set up automated progress tracking."""
+        try:
+            # Initialize progress tracking state
+            tracking_state = {
+                "enabled": True,
+                "last_sync": datetime.now(UTC).isoformat(),
+                "tracked_metrics": [
+                    "commit_frequency",
+                    "issue_completion_rate",
+                    "milestone_progress",
+                    "team_velocity",
+                ],
+            }
+
+            tracking_file = Path(".roadmap_progress_tracking.json")
+            tracking_file.write_text(json.dumps(tracking_state, indent=2))
+            return True
+
+        except Exception as e:
+            logger.error(
+                "progress_tracking_setup_failed", error=str(e), severity="system_error"
+            )
+            return False
+
+    def sync_all_issues_with_git(self) -> dict[str, Any]:
+        """Sync all issues with their Git activity."""
+        results = {"synced_issues": 0, "updated_issues": [], "errors": []}
+
+        try:
+            issues = self.core.issues.list()
+            commits = self.git_integration.get_recent_commits(count=100)
+
+            # Build commit lookup by issue references
+            issue_commits = {}
+            for commit in commits:
+                references = commit.extract_roadmap_references()
+                for issue_id in references:
+                    if issue_id not in issue_commits:
+                        issue_commits[issue_id] = []
+                    issue_commits[issue_id].append(commit)
+
+            # Update issues based on their Git activity
+            for issue in issues:
+                if issue.id in issue_commits:
+                    try:
+                        updated = self._sync_issue_with_commits(
+                            issue, issue_commits[issue.id]
+                        )
+                        if updated:
+                            results["synced_issues"] += 1
+                            results["updated_issues"].append(
+                                {
+                                    "id": issue.id,
+                                    "title": issue.title,
+                                    "commits": len(issue_commits[issue.id]),
+                                }
+                            )
+                    except Exception as e:
+                        results["errors"].append(f"Issue {issue.id}: {str(e)}")
+
+        except Exception as e:
+            results["errors"].append(f"Sync error: {str(e)}")
+
+        return results
+
+    def _sync_issue_with_commits(self, issue: Issue, commits: list[GitCommit]) -> bool:
+        """Sync a single issue with its Git commits."""
+        updated = False
+
+        # Sort commits by date
+        commits.sort(key=lambda c: c.date)
+
+        # Initialize git_commits if not present
+        if not hasattr(issue, "git_commits"):
+            issue.git_commits = []
+
+        # Process commits and extract progress information
+        highest_progress, is_completed = self._process_commits_for_issue(issue, commits)
+
+        # Update issue status and progress based on extracted data
+        updated = self._update_issue_status_and_progress(
+            issue, highest_progress, is_completed
+        )
+
+        if updated:
+            issue_path = self.core.issues_dir / issue.filename
+            IssueParser.save_issue_file(issue, issue_path)
+
+        return updated
+
+    def _process_commits_for_issue(
+        self, issue: Issue, commits: list[GitCommit]
+    ) -> tuple[float | None, bool]:
+        """Process commits for an issue and extract progress and completion status.
+
+        Returns:
+            Tuple of (highest_progress_percentage, is_completed_bool)
+        """
+        highest_progress: float | None = None
+        is_completed = False
+
+        for commit in commits:
+            # Check if commit already tracked
+            if any(ref.get("hash") == commit.hash for ref in issue.git_commits):
+                continue
+
+            # Extract progress from commit
+            progress = commit.extract_progress_info()
+            if progress is not None:
+                if highest_progress is None or progress > highest_progress:
+                    highest_progress = progress
+
+            # Check for completion keywords in commit message
+            if self._is_completion_commit(commit):
+                is_completed = True
+
+            # Build and add commit reference
+            self._add_commit_reference_to_issue(
+                issue, commit, progress, is_completed, commits
+            )
+
+        return highest_progress, is_completed
+
+    def _is_completion_commit(self, commit: GitCommit) -> bool:
+        """Check if commit contains completion keywords."""
+        completion_keywords = ["closes roadmap:", "fixes roadmap:"]
+        return any(keyword in commit.message.lower() for keyword in completion_keywords)
+
+    def _add_commit_reference_to_issue(
+        self,
+        issue: Issue,
+        commit: GitCommit,
+        progress: float | None,
+        is_completed: bool,
+        commits: list[GitCommit],
+    ):
+        """Add a commit reference to the issue's git_commits list."""
+        commit_ref = {
+            "hash": commit.hash,
+            "message": commit.message,
+            "date": commit.date.isoformat(),
+            "progress": progress,
+            "completion": is_completed and commit == commits[-1],
+        }
+        issue.git_commits.append(commit_ref)
+
+    def _update_issue_status_and_progress(
+        self, issue: Issue, highest_progress: float | None, is_completed: bool
+    ) -> bool:
+        """Update issue status and progress based on extracted data.
+
+        Returns:
+            True if issue was updated, False otherwise.
+        """
+        updated = False
+
+        # Update progress percentage
+        if highest_progress is not None:
+            issue.progress_percentage = highest_progress
+            updated = True
+        elif is_completed:
+            # If completed without explicit progress, set to 100%
+            issue.progress_percentage = 100.0
+            updated = True
+
+        # Update status based on completion and progress
+        if is_completed and issue.status != Status.CLOSED:
+            issue.status = Status.CLOSED
+            issue.completed_date = datetime.now(UTC).isoformat()
+            updated = True
+        elif highest_progress and highest_progress > 0 and issue.status == Status.TODO:
+            issue.status = Status.IN_PROGRESS
+            updated = True
+
+        return updated

roadmap/adapters/github/__init__.py

@@ -0,0 +1 @@
+"""GitHub API adapter and issue operations."""

roadmap/adapters/github/github.py

@@ -0,0 +1,360 @@
+"""GitHub API client for roadmap CLI."""
+
+import os
+from typing import Any, cast
+
+import requests
+from requests.adapters import HTTPAdapter
+from structlog import get_logger
+from urllib3.util.retry import Retry
+
+from roadmap.adapters.github.handlers.base import (
+    BaseGitHubHandler,
+    GitHubAPIError,
+)
+from roadmap.adapters.github.handlers.labels import LabelHandler
+from roadmap.infrastructure.security.credentials import get_credential_manager
+
+logger = get_logger()
+
+
+class GitHubClient(BaseGitHubHandler):
+    """GitHub API client for managing issues and milestones."""
+
+    def __init__(
+        self,
+        token: str | None = None,
+        owner: str | None = None,
+        repo: str | None = None,
+    ):
+        """Initialize GitHub client.
+
+        Args:
+            token: GitHub personal access token
+            owner: Repository owner (username or organization)
+            repo: Repository name
+        """
+        # Try to get token from multiple sources with priority:
+        # 1. Explicit parameter
+        # 2. Environment variable
+        # 3. Credential manager
+        self.token = token or self._get_token_secure()
+        self.owner = owner
+        self.repo = repo
+
+        if not self.token:
+            raise GitHubAPIError(
+                "GitHub token is required. Set GITHUB_TOKEN environment variable, use credential manager, or provide token."
+            )
+
+        # Set up session with retry strategy
+        self.session = requests.Session()
+        retry_strategy = Retry(
+            total=3,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=[
+                "HEAD",
+                "GET",
+                "POST",
+                "PUT",
+                "DELETE",
+                "OPTIONS",
+                "TRACE",
+            ],
+        )
+        adapter = HTTPAdapter(max_retries=cast(int, retry_strategy))
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+
+        # Set default headers
+        self.session.headers.update(
+            {
+                "Authorization": f"token {self.token}",
+                "Accept": "application/vnd.github.v3+json",
+                "User-Agent": "roadmap-cli/1.0",
+            }
+        )
+
+        # Initialize label handler
+        self._label_handler = LabelHandler(self.session, owner, repo)
+
+        # Initialize issue handler
+        from roadmap.adapters.github.handlers.issues import IssueHandler
+
+        self._issue_handler = IssueHandler(self.session, owner, repo)
+
+    def _get_token_secure(self) -> str | None:
+        """Get token from secure sources (environment variable or credential manager)."""
+        # First try environment variable
+        env_token = os.getenv("GITHUB_TOKEN")
+        if env_token:
+            return env_token
+
+        # Then try credential manager
+        try:
+            credential_manager = get_credential_manager()
+            return credential_manager.get_token()
+        except Exception as e:
+            logger.debug("credential_manager_failed", error=str(e))
+            return None
+
+    def set_repository(self, owner: str, repo: str) -> None:
+        """Set the target repository."""
+        self.owner = owner
+        self.repo = repo
+
+    def test_authentication(self) -> dict[str, Any]:
+        """Test authentication and get user info."""
+        response = self._make_request("GET", "/user")
+        return response.json()
+
+    def test_repository_access(self) -> dict[str, Any]:
+        """Test repository access."""
+        self._check_repository()
+        response = self._make_request("GET", f"/repos/{self.owner}/{self.repo}")
+        return response.json()
+
+    def status_to_labels(self, status: str) -> list[str]:
+        """Convert issue status to GitHub labels.
+
+        Args:
+            status: The issue status (e.g., 'todo', 'in-progress', 'blocked', 'review', 'closed')
+
+        Returns:
+            List of GitHub labels corresponding to the status
+        """
+        status_label_map = {
+            "todo": ["status:todo"],
+            "in-progress": ["status:in-progress"],
+            "blocked": ["status:blocked"],
+            "review": ["status:review"],
+            "closed": ["status:closed"],
+        }
+        return status_label_map.get(status, [])
+
+    def labels_to_status(self, labels: list[str]) -> str | None:
+        """Convert GitHub labels to issue status.
+
+        Args:
+            labels: List of GitHub labels
+
+        Returns:
+            The corresponding issue status, or None if no status label found
+        """
+        label_status_map = {
+            "status:todo": "todo",
+            "status:in-progress": "in-progress",
+            "status:blocked": "blocked",
+            "status:review": "review",
+            "status:closed": "closed",
+        }
+        for label in labels:
+            if label in label_status_map:
+                return label_status_map[label]
+        return None
+
+    def get_labels(self) -> list[dict[str, Any]]:
+        """Get repository labels.
+
+        Returns:
+            List of label dictionaries
+        """
+        self._label_handler.owner = self.owner
+        self._label_handler.repo = self.repo
+        return self._label_handler.get_labels()
+
+    def create_label(
+        self, name: str, color: str, description: str | None = None
+    ) -> dict[str, Any]:
+        """Create a new label.
+
+        Args:
+            name: Label name
+            color: Label color (hex code)
+            description: Label description
+
+        Returns:
+            Created label dictionary
+        """
+        self._label_handler.owner = self.owner
+        self._label_handler.repo = self.repo
+        return self._label_handler.create_label(name, color, description)
+
+    def setup_default_labels(self) -> None:
+        """Set up default labels for priority and status."""
+        self._label_handler.owner = self.owner
+        self._label_handler.repo = self.repo
+        self._label_handler.setup_default_labels()
+
+    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.
+
+        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: Number of issues per page (max 100)
+
+        Returns:
+            List of issue dictionaries
+        """
+        self._issue_handler.owner = self.owner
+        self._issue_handler.repo = self.repo
+        return self._issue_handler.get_issues(
+            state=state,
+            labels=labels,
+            milestone=milestone,
+            assignee=assignee,
+            per_page=per_page,
+        )
+
+    def fetch_issue(self, issue_number: int) -> dict[str, Any]:
+        """Fetch a GitHub issue by number.
+
+        Args:
+            issue_number: GitHub issue number (must be positive integer)
+
+        Returns:
+            Dictionary with issue details: number, title, body, state, labels, assignees
+
+        Raises:
+            GitHubAPIError: If issue not found or API error occurs
+            ValueError: If issue_number is invalid
+        """
+        if not isinstance(issue_number, int) or issue_number <= 0:
+            raise ValueError(
+                f"Issue number must be a positive integer, got {issue_number}"
+            )
+
+        self._check_repository()
+        try:
+            response = self._make_request(
+                "GET", f"/repos/{self.owner}/{self.repo}/issues/{issue_number}"
+            )
+            data = response.json()
+
+            # Extract relevant fields
+            return {
+                "number": data.get("number"),
+                "title": data.get("title"),
+                "body": data.get("body") or "",
+                "state": data.get("state"),  # 'open' or 'closed'
+                "labels": [label["name"] for label in data.get("labels", [])],
+                "assignees": [
+                    assignee["login"] for assignee in data.get("assignees", [])
+                ],
+                "milestone": data.get("milestone", {}).get("title")
+                if data.get("milestone")
+                else None,
+                "url": data.get("html_url"),
+                "created_at": data.get("created_at"),
+                "updated_at": data.get("updated_at"),
+            }
+        except requests.exceptions.HTTPError as e:
+            resp = e.response
+            if resp is None:
+                raise GitHubAPIError(f"GitHub API error: {e}") from e
+            if resp.status_code == 404:
+                raise GitHubAPIError(
+                    f"GitHub issue #{issue_number} not found in {self.owner}/{self.repo}"
+                ) from e
+            elif resp.status_code == 401:
+                raise GitHubAPIError(
+                    "GitHub authentication failed - invalid token"
+                ) from e
+            else:
+                raise GitHubAPIError(
+                    f"GitHub API error: {resp.status_code} {resp.reason}"
+                ) from e
+        except requests.exceptions.RequestException as e:
+            raise GitHubAPIError(f"GitHub API connection error: {str(e)}") from e
+
+    def validate_github_token(self) -> tuple[bool, str]:
+        """Validate GitHub token by making a test API call.
+
+        Returns:
+            Tuple of (is_valid, message)
+            - (True, "Token is valid") if successful
+            - (False, error_message) if invalid or error
+        """
+        try:
+            response = self._make_request("GET", "/user")
+            if response.status_code == 200:
+                user_data = response.json()
+                login = user_data.get("login", "unknown")
+                return True, f"Token is valid (authenticated as {login})"
+            else:
+                return False, f"Token validation failed: {response.status_code}"
+        except requests.exceptions.HTTPError as e:
+            resp = e.response
+            if resp is None:
+                return False, f"GitHub API error: {e}"
+            if resp.status_code == 401:
+                return False, "GitHub token is invalid or expired"
+            else:
+                return False, f"GitHub API error: {resp.status_code}"
+        except requests.exceptions.RequestException as e:
+            return False, f"GitHub API connection error: {str(e)}"
+
+    def validate_assignee(self, assignee: str) -> tuple[bool, str]:
+        """Validate that a user is a valid assignee for this repository.
+
+        Args:
+            assignee: GitHub username to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+            - (True, "") if valid
+            - (False, error_message) if invalid
+        """
+        if not assignee or not assignee.strip():
+            return False, "Assignee cannot be empty"
+
+        assignee = assignee.strip()
+
+        try:
+            self._check_repository()
+            # Check if the user exists and has access to the repository
+            # We'll try to get the user info from GitHub
+            response = self._make_request("GET", f"/users/{assignee}")
+
+            if response.status_code == 200:
+                # User exists, now check if they have access to the repository
+                # Try to get their permission level in the repository
+                perm_response = self._make_request(
+                    "GET",
+                    f"/repos/{self.owner}/{self.repo}/collaborators/{assignee}/permission",
+                )
+
+                if perm_response.status_code == 204:
+                    # User has some level of access to the repository
+                    return True, ""
+                elif perm_response.status_code == 404:
+                    # User exists but is not a collaborator - they can still be assigned
+                    # to public repositories by maintainers, so return True
+                    return True, ""
+                else:
+                    return False, f"Could not verify access for {assignee}"
+            elif response.status_code == 404:
+                return False, f"GitHub user '{assignee}' not found"
+            else:
+                return False, f"GitHub API error: {response.status_code}"
+
+        except requests.exceptions.HTTPError as e:
+            resp = e.response
+            if resp is None:
+                return False, f"GitHub API error: {e}"
+            if resp.status_code == 404:
+                return False, f"GitHub user '{assignee}' not found"
+            else:
+                return False, f"GitHub API error: {resp.status_code}"
+        except requests.exceptions.RequestException as e:
+            return False, f"GitHub API connection error: {str(e)}"

roadmap/adapters/github/handlers/__init__.py

@@ -0,0 +1,17 @@
+"""GitHub API handlers for different resource types."""
+
+from roadmap.adapters.github.handlers.base import BaseGitHubHandler
+from roadmap.adapters.github.handlers.collaborators import CollaboratorsHandler
+from roadmap.adapters.github.handlers.comments import CommentsHandler
+from roadmap.adapters.github.handlers.issues import IssueHandler
+from roadmap.adapters.github.handlers.labels import LabelHandler
+from roadmap.adapters.github.handlers.milestones import MilestoneHandler
+
+__all__ = [
+    "BaseGitHubHandler",
+    "IssueHandler",
+    "MilestoneHandler",
+    "LabelHandler",
+    "CommentsHandler",
+    "CollaboratorsHandler",
+]