roadmap-cli 0.1.1__py3-none-any.whl

roadmap/infrastructure/coordination/user_operations.py

@@ -0,0 +1,150 @@
+"""User and Team Operations Module - Handles user management and validation.
+
+This module encapsulates user and team management responsibilities extracted from RoadmapCore,
+including team member retrieval, user validation, and assignee management.
+
+Responsibilities:
+- Team member retrieval and caching
+- Current user management
+- Assignee validation and normalization
+- Issue assignment queries by user
+"""
+
+from roadmap.core.domain import Issue
+from roadmap.core.interfaces.assignee_validator import AssigneeValidator
+from roadmap.core.services import GitHubIntegrationService, IssueService
+
+
+class UserOperations:
+    """Manager for user and team-related operations."""
+
+    def __init__(
+        self,
+        github_service: GitHubIntegrationService,
+        issue_service: IssueService,
+        assignee_validator: AssigneeValidator | None = None,
+    ):
+        """Initialize user operations manager.
+
+        Args:
+            github_service: The GitHubIntegrationService instance
+            issue_service: The IssueService instance
+            assignee_validator: Validator for assignees (injected based on backend).
+                               If None, uses vanilla validator for backwards compatibility.
+        """
+        self.github_service = github_service
+        self.issue_service = issue_service
+
+        # Use injected validator, or fall back to vanilla validator
+        if assignee_validator is None:
+            from roadmap.infrastructure.validation.vanilla_assignee_validator import (
+                VanillaAssigneeValidator,
+            )
+
+            assignee_validator = VanillaAssigneeValidator()
+
+        self.assignee_validator = assignee_validator
+
+    def get_team_members(self) -> list[str]:
+        """Get team members from GitHub repository.
+
+        Returns:
+            List of usernames if GitHub is configured, empty list otherwise
+        """
+        return self.github_service.get_team_members()
+
+    def get_current_user(self) -> str | None:
+        """Get the current user from config.
+
+        Returns:
+            Current user's name from config if set, None otherwise
+        """
+        return self.github_service.get_current_user()
+
+    def get_assigned_issues(self, assignee: str) -> list[Issue]:
+        """Get all issues assigned to a specific user.
+
+        Args:
+            assignee: The username to get issues for
+
+        Returns:
+            List of Issue objects assigned to the user
+        """
+        return self.issue_service.list_issues(assignee=assignee)
+
+    def get_my_issues(self) -> list[Issue]:
+        """Get all issues assigned to the current user.
+
+        Returns:
+            List of Issue objects assigned to current user, or empty list if not set
+        """
+        current_user = self.get_current_user()
+        if not current_user:
+            return []
+        return self.get_assigned_issues(current_user)
+
+    def get_all_assigned_issues(self) -> dict[str, list[Issue]]:
+        """Get all issues grouped by assignee.
+
+        Returns:
+            Dictionary mapping assignee usernames to their assigned issues
+        """
+        all_issues = self.issue_service.list_issues()
+        assigned_issues: dict[str, list[Issue]] = {}
+
+        for issue in all_issues:
+            if issue.assignee:
+                if issue.assignee not in assigned_issues:
+                    assigned_issues[issue.assignee] = []
+                assigned_issues[issue.assignee].append(issue)
+
+        return assigned_issues
+
+    def get_cached_team_members(self) -> list[str]:
+        """Get team members with caching (5 minute cache).
+
+        Returns:
+            List of cached team member usernames
+        """
+        return self.github_service.get_cached_team_members()
+
+    def validate_assignee(self, assignee: str) -> tuple[bool, str]:
+        """Validate an assignee using the configured validator.
+
+        The validator is backend-specific:
+        - GitHub backend: validates against repository collaborators
+        - Git backend: accepts any assignee (no-op validator)
+
+        Args:
+            assignee: Username to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+            - (True, "") if valid
+            - (False, error_message) if invalid
+        """
+        return self.assignee_validator.validate(assignee)
+
+    def legacy_validate_assignee(self, assignee: str) -> tuple[bool, str]:
+        """Legacy validation fallback for when validation strategy fails.
+
+        Args:
+            assignee: Username to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        return self.github_service._legacy_validate_assignee(assignee)
+
+    def get_canonical_assignee(self, assignee: str) -> str:
+        """Get the canonical form of an assignee name.
+
+        This method should be called after validate_assignee to get the canonical form.
+
+        Args:
+            assignee: Input assignee name
+
+        Returns:
+            Canonical assignee name (may be same as input if no mapping exists)
+        """
+        return self.assignee_validator.get_canonical_assignee(assignee)

roadmap/infrastructure/coordination/validation_coordinator.py

@@ -0,0 +1,249 @@
+"""Validation Coordinator - Coordinates validation operations.
+
+Extracted from RoadmapCore to reduce god object complexity.
+Provides a focused API for validation concerns.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from roadmap.common.errors.error_standards import OperationType, safe_operation
+from roadmap.common.logging import get_logger
+from roadmap.core.services import GitHubIntegrationService
+
+if TYPE_CHECKING:
+    from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = get_logger(__name__)
+
+
+class ValidationCoordinator:
+    """Coordinates all validation operations."""
+
+    def __init__(
+        self, github_service: GitHubIntegrationService, core: RoadmapCore | None = None
+    ):
+        """Initialize coordinator with GitHub service.
+
+        Args:
+            github_service: GitHubIntegrationService instance
+            core: RoadmapCore instance for initialization checks
+        """
+        self._github_service = github_service
+        self._core = core
+
+    @safe_operation(OperationType.READ, "Configuration")
+    def get_github_config(self) -> tuple[str | None, str | None, str | None]:
+        """Get GitHub configuration from config file and credentials.
+
+        Returns:
+            Tuple of (token, owner, repo) or (None, None, None) if not configured
+        """
+        logger.info("getting_github_config")
+        return self._github_service.get_github_config()
+
+    @safe_operation(OperationType.READ, "RemoteLinks")
+    def collect_remote_link_validation_data(
+        self,
+        issues_dir: Path,
+        backend_name: str = "github",
+    ) -> dict:
+        """Collect YAML and database remote link data for validation.
+
+        Args:
+            issues_dir: Directory containing issue markdown files
+            backend_name: Backend name to validate
+
+        Returns:
+            Dict with issue_files, total_files, yaml_remote_ids, unparseable_files, db_links
+        """
+        if not self._core:
+            raise ValueError("ValidationCoordinator requires RoadmapCore")
+
+        issue_files = sorted(issues_dir.glob("**/*.md")) if issues_dir.exists() else []
+        yaml_remote_ids: dict[str, dict[str, str | int]] = {}
+        unparseable_files: list[tuple[str, str]] = []
+
+        if issue_files:
+            from roadmap.adapters.persistence.parser.issue import IssueParser
+
+            for file_path in issue_files:
+                try:
+                    issue = IssueParser.parse_issue_file(file_path)
+                    if issue.remote_ids:
+                        yaml_remote_ids[issue.id] = issue.remote_ids
+                except Exception as e:
+                    logger.warning(
+                        "failed_to_parse_issue_file",
+                        file_path=str(file_path),
+                        error=str(e),
+                    )
+                    unparseable_files.append((str(file_path), str(e)))
+
+        db_links = self._core.db.remote_links.get_all_links_for_backend(backend_name)
+
+        return {
+            "issue_files": issue_files,
+            "total_files": len(issue_files),
+            "yaml_remote_ids": yaml_remote_ids,
+            "unparseable_files": unparseable_files,
+            "db_links": db_links,
+        }
+
+    @safe_operation(OperationType.READ, "RemoteLinks")
+    def build_remote_link_report(
+        self,
+        yaml_remote_ids: dict[str, dict[str, str | int]],
+        db_links: dict[str, str | int],
+    ) -> dict:
+        """Build a report of remote link discrepancies and duplicates.
+
+        Args:
+            yaml_remote_ids: Mapping of issue_id -> backend_name -> remote_id
+            db_links: Mapping of issue_uuid -> remote_id
+
+        Returns:
+            Dict with validation summary fields
+        """
+        yaml_issue_uuids = set(yaml_remote_ids.keys())
+        db_issue_uuids = set(db_links.keys())
+
+        missing_in_db = [
+            uuid for uuid in yaml_issue_uuids if uuid not in db_issue_uuids
+        ]
+        extra_in_db = [uuid for uuid in db_issue_uuids if uuid not in yaml_issue_uuids]
+
+        duplicate_remote_ids: dict[str, list[str]] = {}
+        remote_id_map: dict[str, list[str]] = {}
+        for issue_uuid, remote_id in db_links.items():
+            remote_id_key = str(remote_id)
+            remote_id_map.setdefault(remote_id_key, []).append(issue_uuid)
+
+        for remote_id, issue_uuids in remote_id_map.items():
+            if len(issue_uuids) > 1:
+                duplicate_remote_ids[remote_id] = issue_uuids
+
+        return {
+            "files_with_remote_ids": len(yaml_remote_ids),
+            "database_links": len(db_links),
+            "missing_in_db": missing_in_db,
+            "extra_in_db": extra_in_db,
+            "duplicate_remote_ids": duplicate_remote_ids,
+        }
+
+    @safe_operation(OperationType.UPDATE, "RemoteLinks")
+    def apply_remote_link_fixes(
+        self,
+        yaml_remote_ids: dict[str, dict[str, str | int]],
+        report: dict,
+        backend_name: str = "github",
+        prune_extra: bool = False,
+        dedupe: bool = False,
+        dry_run: bool = False,
+    ) -> dict:
+        """Apply fixes for missing, extra, and duplicate remote links.
+
+        Args:
+            yaml_remote_ids: Mapping of issue_id -> backend_name -> remote_id
+            report: Validation report dict
+            backend_name: Backend name to fix
+            prune_extra: Remove links missing from YAML
+            dedupe: Remove duplicate remote_id links
+            dry_run: If True, do not apply changes
+
+        Returns:
+            Dict with counts for fixed, removed, and deduped links
+        """
+        if not self._core:
+            raise ValueError("ValidationCoordinator requires RoadmapCore")
+
+        fixed_count = self._fix_missing_links(
+            report.get("missing_in_db", []), yaml_remote_ids, dry_run
+        )
+        removed_count = (
+            self._prune_extra_links(
+                report.get("extra_in_db", []), backend_name, dry_run
+            )
+            if prune_extra
+            else 0
+        )
+        deduped_count = (
+            self._dedupe_links(
+                report.get("duplicate_remote_ids", {}),
+                set(yaml_remote_ids.keys()),
+                backend_name,
+                dry_run,
+            )
+            if dedupe
+            else 0
+        )
+        return {
+            "fixed_count": fixed_count,
+            "removed_count": removed_count,
+            "deduped_count": deduped_count,
+        }
+
+    def _fix_missing_links(
+        self, missing_ids: list, yaml_remote_ids: dict, dry_run: bool
+    ) -> int:
+        core = self._core
+        if core is None:
+            raise ValueError("ValidationCoordinator requires RoadmapCore")
+
+        fixed = 0
+        for issue_uuid in missing_ids:
+            remote_ids = yaml_remote_ids.get(issue_uuid)
+            if not remote_ids:
+                continue
+            if dry_run:
+                fixed += 1
+                continue
+            for backend_key, remote_id in remote_ids.items():
+                core.db.remote_links.link_issue(issue_uuid, backend_key, remote_id)
+            fixed += 1
+        return fixed
+
+    def _prune_extra_links(
+        self, extra_ids: list, backend_name: str, dry_run: bool
+    ) -> int:
+        core = self._core
+        if core is None:
+            raise ValueError("ValidationCoordinator requires RoadmapCore")
+
+        removed = 0
+        for issue_uuid in extra_ids:
+            if dry_run:
+                removed += 1
+                continue
+            if core.db.remote_links.unlink_issue(issue_uuid, backend_name):
+                removed += 1
+        return removed
+
+    def _dedupe_links(
+        self,
+        duplicates: dict,
+        yaml_issue_uuids: set,
+        backend_name: str,
+        dry_run: bool,
+    ) -> int:
+        core = self._core
+        if core is None:
+            raise ValueError("ValidationCoordinator requires RoadmapCore")
+
+        deduped = 0
+        for issue_uuids in duplicates.values():
+            keep_uuid = next(
+                (uuid for uuid in issue_uuids if uuid in yaml_issue_uuids),
+                issue_uuids[0],
+            )
+            for issue_uuid in issue_uuids:
+                if issue_uuid == keep_uuid:
+                    continue
+                if dry_run:
+                    deduped += 1
+                    continue
+                if core.db.remote_links.unlink_issue(issue_uuid, backend_name):
+                    deduped += 1
+        return deduped

roadmap/infrastructure/coordination_gateway.py

@@ -0,0 +1,152 @@
+"""Gateway to coordination infrastructure adapter access for core services.
+
+This module mediates all core service access to infrastructure coordination
+implementations, ensuring proper layer separation between Core and Infrastructure.
+
+All imports from roadmap.adapters accessed via coordination are localized here.
+Core services use this gateway instead of importing coordination modules directly
+or accessing adapters through coordination.
+"""
+
+from pathlib import Path
+from typing import Any
+
+
+class CoordinationGateway:
+    """Gateway for infrastructure coordination operations.
+
+    Provides a centralized interface for core services to access coordination
+    functionality that internally uses adapters (git, persistence, etc.)
+    without direct adapter imports in core.
+    """
+
+    @staticmethod
+    def get_git_integration(repo_path: Path | None = None, config: Any = None) -> Any:
+        """Get GitIntegration adapter for git operations.
+
+        Args:
+            repo_path: Path to git repository
+            config: Configuration object
+
+        Returns:
+            GitIntegration instance from adapters
+        """
+        from roadmap.adapters.git.git import GitIntegration
+
+        return GitIntegration(repo_path=repo_path, config=config)
+
+    @staticmethod
+    def get_state_manager(db_path: Path | str | None = None) -> Any:
+        """Get StateManager for database operations.
+
+        Args:
+            db_path: Path to database file (optional)
+
+        Returns:
+            StateManager instance from adapters
+        """
+        from roadmap.adapters.persistence.storage import StateManager
+
+        if db_path:
+            return StateManager(db_path)
+        return StateManager()
+
+    @staticmethod
+    def get_yaml_issue_repository(
+        db: Any | None = None, issues_dir: Path | None = None
+    ) -> Any:
+        """Get YAML repository for issue persistence.
+
+        Args:
+            db: Database instance
+            issues_dir: Path to issues directory
+
+        Returns:
+            YAMLIssueRepository instance from adapters
+        """
+        from roadmap.adapters.persistence.yaml_repositories import (
+            YAMLIssueRepository,
+        )
+
+        # Both parameters are required
+        if db is None or issues_dir is None:
+            raise ValueError("Both 'db' and 'issues_dir' are required parameters")
+        return YAMLIssueRepository(db, issues_dir)
+
+    @staticmethod
+    def get_git_sync_monitor(
+        repo_path: Path | None = None, state_manager: Any = None
+    ) -> Any:
+        """Get GitSyncMonitor for git sync tracking.
+
+        Args:
+            repo_path: Path to git repository
+            state_manager: State manager instance
+
+        Returns:
+            GitSyncMonitor instance from adapters
+        """
+        from roadmap.adapters.git.sync_monitor import GitSyncMonitor
+
+        return GitSyncMonitor(repo_path=repo_path, state_manager=state_manager)
+
+    @staticmethod
+    def get_git_hook_manager(core: Any) -> Any:
+        """Get GitHookManager for git hook operations.
+
+        Args:
+            core: RoadmapCore instance (required)
+
+        Returns:
+            GitHookManager instance from adapters
+        """
+        from roadmap.adapters.git.git_hooks import GitHookManager
+
+        return GitHookManager(core)
+
+    @staticmethod
+    def parse_issue(file_path: Any) -> Any:
+        """Parse issue from file.
+
+        Args:
+            file_path: Path to issue file
+
+        Returns:
+            Parsed Issue object
+        """
+        from roadmap.adapters.persistence.parser import IssueParser
+
+        return IssueParser.parse_issue_file(file_path)
+
+    @staticmethod
+    def parse_milestone(file_path: Any) -> Any:
+        """Parse milestone from file.
+
+        Args:
+            file_path: Path to milestone file
+
+        Returns:
+            Parsed Milestone object
+        """
+        from roadmap.adapters.persistence.parser import MilestoneParser
+
+        return MilestoneParser.parse_milestone_file(file_path)
+
+    @staticmethod
+    def get_yaml_repositories_manager() -> Any:
+        """Get combined repositories manager for multi-repo operations.
+
+        Returns:
+            Dictionary of repository classes available
+        """
+        from roadmap.adapters.persistence.yaml_repositories import (
+            YAMLIssueRepository,
+            YAMLMilestoneRepository,
+            YAMLProjectRepository,
+        )
+
+        return {
+            "issue": YAMLIssueRepository,
+            "milestone": YAMLMilestoneRepository,
+            "project": YAMLProjectRepository,
+        }

roadmap/infrastructure/git/__init__.py

@@ -0,0 +1,6 @@
+"""Git integration layer - Coordinates git operations and branch linking.
+
+This module handles:
+- Git coordinator: Orchestrates git operations
+- Git integration ops: Concrete git operation implementations
+"""