roadmap-cli 0.1.1__py3-none-any.whl

roadmap/infrastructure/coordination/core.py

@@ -0,0 +1,446 @@
+"""RoadmapCore - Lightweight Service Container and Coordinator.
+
+RoadmapCore is a lightweight facade that provides a clean, domain-organized
+API by coordinating across multiple specialized domain coordinators.
+
+Instead of being a god object with 50+ methods, RoadmapCore now delegates
+to focused domain coordinators:
+- IssueCoordinator: Issue CRUD and queries
+- MilestoneCoordinator: Milestone CRUD and consistency validation
+- ProjectCoordinator: Project CRUD and management
+- TeamCoordinator: Team member and user management
+- GitCoordinator: Git integration and branch linking
+- ValidationCoordinator: Validation and configuration
+
+This design:
+- Keeps RoadmapCore <200 LOC (down from 670 LOC)
+- Makes each domain independently testable
+- Provides a clear mental model for users
+- Scales well for future features
+"""
+
+from pathlib import Path
+
+from roadmap.common.logging import get_logger
+from roadmap.common.utils.path_utils import build_roadmap_paths
+from roadmap.core.services import (
+    ConfigurationService,
+    GitHubIntegrationService,
+    IssueService,
+    MilestoneService,
+    ProjectService,
+)
+from roadmap.infrastructure.coordination.git_coordinator import GitCoordinator
+from roadmap.infrastructure.coordination.initialization import InitializationManager
+from roadmap.infrastructure.coordination.issue_coordinator import IssueCoordinator
+from roadmap.infrastructure.coordination.issue_operations import IssueOperations
+from roadmap.infrastructure.coordination.milestone_coordinator import (
+    MilestoneCoordinator,
+)
+from roadmap.infrastructure.coordination.milestone_operations import MilestoneOperations
+from roadmap.infrastructure.coordination.project_coordinator import ProjectCoordinator
+from roadmap.infrastructure.coordination.project_operations import ProjectOperations
+from roadmap.infrastructure.coordination.team_coordinator import TeamCoordinator
+from roadmap.infrastructure.coordination.user_operations import UserOperations
+from roadmap.infrastructure.coordination.validation_coordinator import (
+    ValidationCoordinator,
+)
+from roadmap.infrastructure.coordination_gateway import CoordinationGateway
+from roadmap.infrastructure.git.git_integration_ops import GitIntegrationOps
+
+logger = get_logger(__name__)
+
+
+class RoadmapCore:
+    """Lightweight service container and coordinator of domain coordinators.
+
+    RoadmapCore provides a clean, organized API by delegating to focused
+    domain coordinators for each concern (issues, milestones, projects, etc).
+
+    Usage:
+        core = RoadmapCore()
+        core.initialize()  # One-time setup
+
+        # Use domain-specific coordinators
+        issue = core.issues.create(title="...")
+        milestone = core.milestones.create(name="...")
+        members = core.team.get_members()
+        commits = core.git.get_commits_for_issue("issue-123")
+    """
+
+    def __init__(
+        self, root_path: Path | None = None, roadmap_dir_name: str = ".roadmap"
+    ):
+        """Initialize RoadmapCore with service setup and coordinators.
+
+        Args:
+            root_path: Root path for the roadmap (defaults to cwd)
+            roadmap_dir_name: Name of the roadmap directory (defaults to .roadmap)
+        """
+        self.root_path = root_path or Path.cwd()
+        self.roadmap_dir_name = roadmap_dir_name
+
+        # Build all standard roadmap paths
+        paths = build_roadmap_paths(self.root_path, roadmap_dir_name)
+        self.roadmap_dir = paths["roadmap_dir"]
+        self.issues_dir = paths["issues_dir"]
+        self.milestones_dir = paths["milestones_dir"]
+        self.projects_dir = paths["projects_dir"]
+        self.templates_dir = paths["templates_dir"]
+        self.artifacts_dir = paths["artifacts_dir"]
+        self.config_file = paths["config_file"]
+        self.db_dir = paths["db_dir"]
+
+        # Initialize core infrastructure
+        self._git = CoordinationGateway.get_git_integration()
+        self._git.root_path = self.root_path
+
+        # Initialize StateManager with correct project-local database path
+        db_path = self.db_dir / "state.db"
+        self.db = CoordinationGateway.get_state_manager(db_path=db_path)
+
+        # Initialize GitSyncMonitor with StateManager for database sync
+        self.git_sync_monitor = CoordinationGateway.get_git_sync_monitor()
+        self.git_sync_monitor.repo_path = self.root_path
+        self.git_sync_monitor.state_manager = self.db
+
+        # Initialize remote links from YAML (Phase 3)
+        try:
+            self.db.initialize_remote_links(self.root_path)
+        except Exception as e:
+            from roadmap.common.logging import get_logger
+
+            logger = get_logger(__name__)
+            logger.warning(
+                "failed_to_initialize_remote_links_in_core",
+                error=str(e),
+                severity="operational",
+            )
+
+        # Wire GitSyncMonitor into StateManager for transparent cache sync
+        self.db._git_sync_monitor = self.git_sync_monitor
+
+        self.github_service = GitHubIntegrationService(
+            root_path=self.root_path, config_file=self.config_file
+        )
+        self.config_service = ConfigurationService()
+
+        # Initialize repositories (abstraction layer)
+        issue_repository = CoordinationGateway.get_yaml_issue_repository(
+            db=self.db, issues_dir=self.issues_dir
+        )
+
+        from roadmap.adapters.persistence.yaml_repositories import (
+            YAMLMilestoneRepository,
+            YAMLProjectRepository,
+        )
+
+        milestone_repository = YAMLMilestoneRepository(self.db, self.milestones_dir)
+        project_repository = YAMLProjectRepository(self.db, self.projects_dir)
+
+        # Initialize services with repository injection
+        # (decoupled from implementation)
+        self.issue_service = IssueService(issue_repository)
+        self.milestone_service = MilestoneService(
+            milestone_repository,
+            issue_repository=issue_repository,
+            issues_dir=self.issues_dir,
+            milestones_dir=self.milestones_dir,
+        )
+        self.project_service = ProjectService(project_repository, self.milestones_dir)
+
+        # Keep reference to init manager for setup (needed before creating coordinators)
+        self._init_manager = InitializationManager(
+            self.root_path, self.roadmap_dir_name
+        )
+
+        # Initialize operations managers
+        issue_ops = IssueOperations(self.issue_service, self.issues_dir)
+        milestone_ops = MilestoneOperations(self.milestone_service)
+        project_ops = ProjectOperations(self.project_service)
+
+        # Determine appropriate assignee validator based on sync backend
+        assignee_validator = self._get_assignee_validator()
+        user_ops = UserOperations(
+            self.github_service, self.issue_service, assignee_validator
+        )
+        git_ops = GitIntegrationOps(self._git, self)
+
+        # Initialize domain coordinators (pass self for initialization check)
+        self.issues = IssueCoordinator(issue_ops, core=self)
+        self.milestones = MilestoneCoordinator(
+            milestone_ops, self.milestones_dir, core=self
+        )
+        self.projects = ProjectCoordinator(project_ops, core=self)
+        self.team = TeamCoordinator(user_ops, core=self)
+        self.git = GitCoordinator(git_ops, core=self)
+        self.validation = ValidationCoordinator(self.github_service, core=self)
+
+    def is_initialized(self) -> bool:
+        """Check if roadmap is initialized in current directory."""
+        return self._init_manager.is_initialized()
+
+    def _check_initialized(self) -> None:
+        """Check that roadmap is initialized and raise if not."""
+        if not self.is_initialized():
+            raise ValueError("Roadmap not initialized. Run 'roadmap init' first.")
+
+    def _get_assignee_validator(self):
+        """Determine the appropriate assignee validator based on sync backend.
+
+        Returns the validator for the configured sync backend:
+        - "github" backend → GitHubAssigneeValidator (validates against collaborators)
+        - "git" or other backend → VanillaAssigneeValidator (accepts any assignee)
+
+        Defaults to vanilla/git validator if no backend is configured.
+
+        Returns:
+            An assignee validator instance (implements AssigneeValidator protocol)
+        """
+        from roadmap.common.configuration import ConfigManager
+        from roadmap.infrastructure.validation.github_assignee_validator import (
+            GitHubAssigneeValidator,
+        )
+        from roadmap.infrastructure.validation.vanilla_assignee_validator import (
+            VanillaAssigneeValidator,
+        )
+
+        try:
+            config_manager = ConfigManager(self.config_file)
+            config = config_manager.load()
+            # Access dataclass attributes, not dictionary
+            sync_backend = config.github.sync_backend if config.github else "git"
+        except Exception:
+            # If we can't read config, default to vanilla/git validator
+            sync_backend = "git"
+
+        if str(sync_backend).lower() == "github":
+            return GitHubAssigneeValidator(self.github_service)
+        else:
+            # Default to vanilla validator for "git" backend or if not specified
+            return VanillaAssigneeValidator()
+
+    @classmethod
+    def find_existing_roadmap(
+        cls, root_path: Path | None = None
+    ) -> "RoadmapCore | None":
+        """Find an existing roadmap directory in the current path.
+
+        Searches for common roadmap directory names and returns a RoadmapCore
+        instance if found, or None if no roadmap is detected.
+        """
+        manager = InitializationManager.find_existing_roadmap(root_path)
+        if manager:
+            return cls(
+                root_path=manager.root_path, roadmap_dir_name=manager.roadmap_dir_name
+            )
+        return None
+
+    def initialize(self) -> None:
+        """Initialize a new roadmap in the current directory."""
+        self._init_manager.initialize()
+
+    def close(self) -> None:
+        """Close any database resources held by this core."""
+        try:
+            self.db.close()
+        except Exception as e:
+            logger.warning(
+                "core_close_failed", error=str(e), error_type=type(e).__name__
+            )
+
+    def __enter__(self) -> "RoadmapCore":
+        """Enter context manager and return self."""
+        return self
+
+    def __exit__(self, _exc_type, _exc, _tb) -> None:
+        """Exit context manager and close resources."""
+        self.close()
+
+    def _update_gitignore(self) -> None:
+        """Update .gitignore to exclude roadmap local data from version control."""
+        self._init_manager._update_gitignore()
+
+    def _sync_with_progress(self, message: str) -> dict | None:
+        """Run database sync with progress display.
+
+        Args:
+            message: Progress message to display
+
+        Returns:
+            Sync result dictionary or None
+        """
+        from rich.progress import Progress, SpinnerColumn, TextColumn
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn(f"[bold blue]{message}..."),
+            transient=True,
+        ) as progress:
+            progress.add_task("sync", total=None)
+            return self.db.smart_sync()
+
+    def _sync_without_progress(self) -> dict | None:
+        """Run database sync without progress display.
+
+        Returns:
+            Sync result dictionary or None
+        """
+        return self.db.smart_sync()
+
+    def _display_sync_result(self, console, message: str, files_synced: int) -> None:
+        """Display sync result message.
+
+        Args:
+            console: Rich console instance
+            message: Message to display
+            files_synced: Number of files synced
+        """
+        console.print(f"✅ {message}: {files_synced} files synced")
+
+    def _handle_first_time_setup(
+        self, console, show_progress: bool, force_rebuild: bool
+    ) -> None:
+        """Handle first-time database initialization.
+
+        Args:
+            console: Rich console instance
+            show_progress: Whether to show progress
+            force_rebuild: Whether full rebuild was requested
+        """
+        if show_progress:
+            sync_result = self._sync_with_progress(
+                "Initializing database from .roadmap/ files"
+            )
+        else:
+            sync_result = self._sync_without_progress()
+
+        if show_progress and sync_result:
+            files_synced = sync_result.get("files_synced", 0)
+            total_files = sync_result.get("total_files", 0)
+            console.print(
+                f"✅ Database initialized: {files_synced}/{total_files} files synced"
+            )
+
+        if not force_rebuild and self._git.is_git_repository():
+            self._ensure_git_hooks_installed(console, show_progress)
+
+    def _handle_incremental_sync(self, console, show_progress: bool) -> None:
+        """Handle incremental database sync.
+
+        Args:
+            console: Rich console instance
+            show_progress: Whether to show progress
+        """
+        if not self.db.has_file_changes():
+            return
+
+        if show_progress:
+            sync_result = self._sync_with_progress(
+                "Updating database with recent changes"
+            )
+        else:
+            sync_result = self._sync_without_progress()
+
+        if show_progress and sync_result:
+            files_synced = sync_result.get("files_synced", 0)
+            self._display_sync_result(console, "Database updated", files_synced)
+
+    def ensure_database_synced(
+        self, force_rebuild: bool = False, show_progress: bool = True
+    ) -> None:
+        """Ensure database is synced with .roadmap/ files.
+
+        This is called automatically on CLI startup to keep SQLite in sync with git files.
+
+        Args:
+            force_rebuild: Force a full rebuild even if database exists
+            show_progress: Show progress indicators during sync
+        """
+        from rich.console import Console
+
+        console = Console()
+
+        if not self.is_initialized():
+            return
+
+        first_time_setup = not self.db.database_exists()
+
+        if first_time_setup or force_rebuild:
+            self._handle_first_time_setup(console, show_progress, first_time_setup)
+        else:
+            self._handle_incremental_sync(console, show_progress)
+
+    def _ensure_git_hooks_installed(self, console, show_progress: bool = True) -> None:
+        """Ensure git hooks are installed for automatic sync."""
+        try:
+            hook_manager = CoordinationGateway.get_git_hook_manager(self)
+
+            if show_progress:
+                console.print("[dim]Installing git hooks for automatic sync...[/dim]")
+
+            success = hook_manager.install_hooks()
+
+            if show_progress:
+                if success:
+                    console.print("✅ Git hooks installed successfully")
+                else:
+                    console.print("[yellow]⚠️  Git hooks installation failed[/yellow]")
+
+        except Exception as e:
+            if show_progress:
+                console.print(f"[yellow]⚠️  Git hooks setup failed: {e}[/yellow]")
+
+    # ========== BACKWARD COMPATIBILITY WRAPPERS ==========
+    # These methods delegate to domain coordinators for backward compatibility
+    # New code should use: core.issues.method(), core.milestones.method(), etc.
+
+    def get_issues_by_milestone(self) -> dict[str, list]:
+        """Get all issues grouped by milestone (backward compatibility wrapper)."""
+        return self.issues.get_grouped_by_milestone()
+
+    def get_next_milestone(self):
+        """Get the next upcoming milestone by due date (backward compatibility wrapper)."""
+        return self.milestones._ops.get_next_milestone()
+
+    def move_issue_to_milestone(self, issue_id: str, milestone_name: str):
+        """Move an issue to a specific milestone (backward compatibility wrapper)."""
+        return self.issues.move_to_milestone(issue_id, milestone_name)
+
+    def load_config(self):
+        """Load roadmap configuration."""
+        if not self.is_initialized():
+            raise ValueError("Roadmap not initialized. Run 'roadmap init' first.")
+
+        import yaml
+
+        with open(self.config_file) as f:
+            loaded = yaml.safe_load(f)
+            config_data: dict = loaded if isinstance(loaded, dict) else {}
+
+        # Ensure all expected config sections exist
+        if "milestones" not in config_data:
+            config_data["milestones"] = {
+                "auto_sequence": True,
+                "version_format": "v{major}.{minor}.{patch}",
+            }
+
+        if "sync" not in config_data:
+            config_data["sync"] = {
+                "github_enabled": False,
+                "auto_sync": False,
+                "sync_interval_seconds": 300,
+            }
+
+        if "display" not in config_data:
+            config_data["display"] = {
+                "theme": "default",
+                "show_progress": True,
+                "compact_output": False,
+            }
+
+        class ConfigObject:
+            def __init__(self, data):
+                self.__dict__.update(data)
+
+        return ConfigObject(config_data)

roadmap/infrastructure/coordination/git_coordinator.py

@@ -0,0 +1,160 @@
+"""Git Coordinator - Coordinates git-related operations.
+
+Extracted from RoadmapCore to reduce god object complexity.
+Provides a focused API for all git integration concerns.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from roadmap.core.domain import Issue
+from roadmap.infrastructure.git.git_integration_ops import GitIntegrationOps
+
+if TYPE_CHECKING:
+    from roadmap.infrastructure.coordination.core import RoadmapCore
+
+
+class GitCoordinator:
+    """Coordinates all git-related operations."""
+
+    def __init__(self, git_ops: GitIntegrationOps, core: RoadmapCore | None = None):
+        """Initialize coordinator with git operations manager.
+
+        Args:
+            git_ops: GitIntegrationOps instance
+            core: RoadmapCore instance for initialization checks
+        """
+        self._ops: GitIntegrationOps = git_ops
+        self._git: Any = git_ops.git
+        self._core = core
+
+    def get_context(self) -> dict[str, Any]:
+        """Get Git repository context information."""
+        return self._ops.get_git_context()
+
+    def get_current_user(self) -> str | None:
+        """Get current user from Git configuration."""
+        return self._ops.get_current_user_from_git()
+
+    def create_issue_with_branch(self, title: str, **kwargs) -> Issue | None:
+        """Create an issue and optionally create a Git branch for it."""
+        return self._ops.create_issue_with_git_branch(title, **kwargs)
+
+    def link_issue_to_branch(self, issue_id: str) -> bool:
+        """Link an issue to the current Git branch."""
+        return self._ops.link_issue_to_current_branch(issue_id)
+
+    def get_commits_for_issue(self, issue_id: str, since: str | None = None) -> list:
+        """Get Git commits that reference this issue."""
+        return self._ops.get_commits_for_issue(issue_id, since)
+
+    def update_issue_from_activity(self, issue_id: str) -> bool:
+        """Update issue progress and status based on Git commit activity."""
+        return self._ops.update_issue_from_git_activity(issue_id)
+
+    def suggest_branch_name(self, issue_id: str) -> str | None:
+        """Suggest a branch name for an issue."""
+        return self._ops.suggest_branch_name_for_issue(issue_id)
+
+    def get_branch_linked_issues(self) -> dict[str, list[str]]:
+        """Get mapping of branches to their linked issue IDs."""
+        return self._ops.get_branch_linked_issues()
+
+    def is_git_repository(self) -> bool:
+        """Check if current directory is a git repository."""
+        return self._ops.git.is_git_repository()
+
+    def create_branch_for_issue(self, issue: Issue, checkout: bool = True) -> bool:
+        """Create a Git branch for an issue.
+
+        Args:
+            issue: The Issue object to create a branch for
+            checkout: If True, checkout the created branch (default: True)
+
+        Returns:
+            True if branch was created successfully, False otherwise
+        """
+        return self._ops.git.create_branch_for_issue(issue, checkout=checkout)
+
+    @property
+    def repo_path(self):
+        """Get the repository path (for backward compatibility)."""
+        return self._ops.git.repo_path
+
+    def get_repository_info(self) -> dict[str, Any]:
+        """Get repository information.
+
+        Returns:
+            Dictionary with repository metadata
+        """
+        return self._git.get_repository_info()
+
+    def get_current_branch(self) -> str | None:
+        """Get the current Git branch name.
+
+        Returns:
+            Current branch name or None if not in a git repo
+        """
+        branch = self._git.get_current_branch()
+        return branch.name if branch else None
+
+    def get_local_changes(self) -> list[str]:
+        """Get list of issue IDs that have changed locally since last sync.
+
+        Compares current issue files in .roadmap/issues with the last committed
+        versions (git HEAD) to detect which issues were modified locally.
+
+        Returns:
+            List of issue IDs that have uncommitted changes
+        """
+        try:
+            import subprocess
+            from pathlib import Path
+
+            issues_dir = self._core.issues_dir if self._core else None
+            if not issues_dir:
+                return []
+
+            # Get modified files relative to git HEAD in the issues directory
+            result = subprocess.run(
+                [
+                    "git",
+                    "diff",
+                    "HEAD",
+                    "--name-only",
+                    "--",
+                    str(issues_dir),
+                ],
+                capture_output=True,
+                text=True,
+                cwd=self._git.repo_path,
+            )
+
+            if result.returncode != 0:
+                # If diff fails, return empty list (might not be in git repo)
+                return []
+
+            # Parse filenames to extract issue IDs
+            changed_issue_ids = []
+            for line in result.stdout.strip().split("\n"):
+                if not line:
+                    continue
+
+                # Extract filename from path (e.g., ".roadmap/issues/ID.md" -> "ID")
+                filepath = Path(line)
+                filename = filepath.stem  # Remove .md extension
+
+                # Validate it looks like an issue ID (uuid-like)
+                if filename and len(filename) > 4:
+                    changed_issue_ids.append(filename)
+
+            return changed_issue_ids
+
+        except Exception as e:
+            # Log but don't crash on git errors
+            if self._core:
+                import structlog
+
+                structlog.get_logger().warning("get_local_changes_failed", error=str(e))
+            return []