roadmap-cli 0.1.1__py3-none-any.whl

roadmap/adapters/cli/git/handlers/git_branch_handler.py

@@ -0,0 +1,238 @@
+"""Handler for Git branch operations."""
+
+import structlog
+from rich.console import Console
+
+from roadmap.adapters.cli.cli_error_handlers import handle_cli_error
+from roadmap.core.domain import Issue, Status
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = structlog.get_logger()
+
+
+class GitBranchHandler:
+    """Handles Git branch creation, linking, and validation."""
+
+    def __init__(self, console: Console):
+        """Initialize handler with console for output.
+
+        Args:
+            console: Rich Console instance
+        """
+        self.console = console
+
+    def validate_branch_environment(self, core: RoadmapCore) -> bool:
+        """Validate roadmap and git environment for branch creation.
+
+        Args:
+            core: RoadmapCore instance
+
+        Returns:
+            True if environment is valid
+        """
+        if not core.is_initialized():
+            self.console.print(
+                "❌ Roadmap not initialized. Run 'roadmap init' first.",
+                style="bold red",
+            )
+            return False
+
+        if not core.git.is_git_repository():
+            self.console.print("❌ Not in a Git repository", style="bold red")
+            return False
+
+        return True
+
+    def get_and_validate_issue(self, core: RoadmapCore, issue_id: str):
+        """Get and validate issue exists.
+
+        Args:
+            core: RoadmapCore instance
+            issue_id: Issue ID to retrieve
+
+        Returns:
+            Issue object or None if not found
+        """
+        issue = core.issues.get(issue_id)
+        if not issue:
+            self.console.print(f"❌ Issue not found: {issue_id}", style="bold red")
+            return None
+        return issue
+
+    def create_branch(self, core: RoadmapCore, issue_id: str, checkout: bool = True):
+        """Create a Git branch for an issue.
+
+        Args:
+            core: RoadmapCore instance
+            issue_id: ID of the issue to create branch for
+            checkout: Whether to checkout the new branch
+
+        Raises:
+            Exception: If branch creation fails
+        """
+        if not self.validate_branch_environment(core):
+            return
+
+        try:
+            issue = self.get_and_validate_issue(core, issue_id)
+            if not issue:
+                return
+
+            branch_name = core.git.suggest_branch_name(issue_id)
+            if not branch_name:
+                self.console.print(
+                    "❌ Could not suggest branch name for issue", style="bold red"
+                )
+                return
+
+            # Create the branch (use a compatibility wrapper)
+            success = self._safe_create_branch(core.git, issue, checkout=checkout)
+
+            if success:
+                self._display_branch_success(branch_name, issue, checkout)
+                self._update_issue_status_if_needed(core, issue, issue_id)
+            else:
+                # Try a direct git fallback using subprocess
+                import subprocess
+
+                try:
+                    subprocess.run(
+                        ["git", "checkout", "-b", branch_name],
+                        cwd=core.git.repo_path,
+                        check=True,
+                        capture_output=True,
+                    )
+                    self._display_branch_success(branch_name, issue, checkout)
+                    self._update_issue_status_if_needed(core, issue, issue_id)
+                except (subprocess.CalledProcessError, FileNotFoundError):
+                    self.console.print("❌ Failed to create branch", style="bold red")
+
+        except Exception as e:
+            handle_cli_error(
+                error=e,
+                operation="create_git_branch",
+                entity_type="issue",
+                entity_id=issue_id,
+                context={"checkout": checkout},
+                fatal=True,
+            )
+            self.console.print(f"❌ Failed to create Git branch: {e}", style="bold red")
+
+    def link_issue_to_branch(self, core: RoadmapCore, issue_id: str):
+        """Link an issue to the current Git branch.
+
+        Args:
+            core: RoadmapCore instance
+            issue_id: ID of the issue to link
+
+        Raises:
+            Exception: If linking fails
+        """
+        if not core.git.is_git_repository():
+            self.console.print("❌ Not in a Git repository", style="bold red")
+            return
+
+        try:
+            issue = core.issues.get(issue_id)
+            if not issue:
+                self.console.print(f"❌ Issue not found: {issue_id}", style="bold red")
+                return
+
+            current_branch = core.git.get_current_branch()
+            if not current_branch:
+                self.console.print(
+                    "❌ Could not determine current branch", style="bold red"
+                )
+                return
+
+            # Link the issue to the current branch
+            success = core.git.link_issue_to_branch(issue_id)
+
+            if success:
+                self.console.print(
+                    f"🔗 Linked issue to branch: {current_branch}",
+                    style="bold green",
+                )
+                self.console.print(f"📋 Issue: {issue.title}", style="cyan")
+                self.console.print(f"🆔 ID: {issue_id}", style="dim")
+            else:
+                self.console.print(
+                    "❌ Failed to link issue to branch", style="bold red"
+                )
+
+        except Exception as e:
+            handle_cli_error(
+                error=e,
+                operation="link_issue_to_branch",
+                entity_type="issue",
+                entity_id=issue_id,
+                context={},
+                fatal=True,
+            )
+            self.console.print(
+                f"❌ Failed to link issue to Git branch: {e}", style="bold red"
+            )
+
+    def _safe_create_branch(self, git, issue, checkout=True) -> bool:
+        """Safely create branch with fallback attempts.
+
+        Args:
+            git: Git executor
+            issue: Issue object
+            checkout: Whether to checkout the new branch
+
+        Returns:
+            True if branch was created
+        """
+        try:
+            return git.create_branch_for_issue(issue, checkout=checkout)
+        except TypeError as e:
+            handle_cli_error(
+                error=e,
+                operation="create_branch_for_issue",
+                entity_type="issue",
+                entity_id=issue.id,
+                context={"checkout": checkout, "error_type": "TypeError"},
+                fatal=False,
+            )
+            try:
+                return git.create_branch_for_issue(issue)
+            except Exception as e:
+                handle_cli_error(
+                    error=e,
+                    operation="create_branch_for_issue_fallback",
+                    entity_type="issue",
+                    entity_id=issue.id,
+                    context={},
+                    fatal=False,
+                )
+                return False
+
+    def _display_branch_success(self, branch_name: str, issue, checkout: bool) -> None:
+        """Display success messages for branch creation.
+
+        Args:
+            branch_name: Name of created branch
+            issue: Issue object
+            checkout: Whether branch was checked out
+        """
+        self.console.print(f"🌿 Created branch: {branch_name}", style="bold green")
+        if checkout:
+            self.console.print(f"✅ Checked out branch: {branch_name}", style="green")
+        self.console.print(f"🔗 Linked to issue: {issue.title}", style="cyan")
+
+    def _update_issue_status_if_needed(
+        self, core: RoadmapCore, issue: Issue, issue_id: str
+    ) -> None:
+        """Update issue status to in-progress if it's todo.
+
+        Args:
+            core: RoadmapCore instance
+            issue: Issue object
+            issue_id: Issue ID
+        """
+        if issue.status == Status.TODO:
+            core.issues.update(issue_id, status=Status.IN_PROGRESS)
+            self.console.print(
+                "📊 Updated issue status to: in-progress", style="yellow"
+            )

roadmap/adapters/cli/git/handlers/git_connectivity_handler.py

@@ -0,0 +1,122 @@
+"""Handler for Git connectivity and authentication testing."""
+
+import structlog
+from rich.console import Console
+
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = structlog.get_logger()
+
+
+class GitConnectivityHandler:
+    """Handles testing and verifying Git repository connectivity."""
+
+    def __init__(self, console: Console):
+        """Initialize handler with console for output.
+
+        Args:
+            console: Rich Console instance
+        """
+        self.console = console
+
+    def test_git_connectivity(self, core: RoadmapCore):
+        """Test and verify Git repository connectivity for self-hosting.
+
+        Args:
+            core: RoadmapCore instance
+
+        Raises:
+            Exception: If git connectivity test fails
+        """
+        from roadmap.adapters.cli.services.sync_service import (
+            get_sync_backend,
+            test_backend_connectivity,
+        )
+
+        self.console.print("🔌 Git Repository Connectivity Test", style="bold cyan")
+        self.console.print()
+
+        # Try to create vanilla git backend to test connectivity
+        self.console.print("🧪 Testing Git repository connectivity...", style="cyan")
+        logger.debug("git_connectivity_testing")
+
+        try:
+            # Use sync service to create vanilla git backend
+            backend = get_sync_backend("git", core, {})
+
+            if backend is None:
+                self.console.print(
+                    "❌ Could not initialize Git backend (not in a git repository?)",
+                    style="bold red",
+                )
+                logger.warning(
+                    "git_backend_initialization_failed", severity="config_error"
+                )
+                return
+
+            # Test authentication (connectivity check)
+            success, message = test_backend_connectivity(backend, "git")
+            if success:
+                self.console.print(message, style="green")
+                self.console.print(
+                    "Your git repository is accessible and ready for syncing",
+                    style="dim",
+                )
+                logger.info("git_connectivity_verified")
+            else:
+                self.console.print(
+                    "⚠️  Could not verify git remote access",
+                    style="yellow",
+                )
+                self.console.print()
+                self.console.print(
+                    "This might be due to:",
+                    style="dim",
+                )
+                self.console.print("  • SSH key not configured", style="dim")
+                self.console.print("  • HTTPS credentials needed", style="dim")
+                self.console.print("  • Network connectivity issues", style="dim")
+                self.console.print(
+                    "  • Remote repository doesn't exist yet",
+                    style="dim",
+                )
+                self.console.print()
+                self.console.print(
+                    "For SSH: Make sure your SSH key is in ~/.ssh/",
+                    style="dim",
+                )
+                self.console.print(
+                    "For HTTPS: Configure git credentials with: git config credential.helper",
+                    style="dim",
+                )
+                logger.warning(
+                    "git_connectivity_verification_failed", severity="infrastructure"
+                )
+
+        except ValueError as e:
+            self.console.print(
+                f"❌ Git repository error: {e}",
+                style="bold red",
+            )
+            logger.error(
+                "git_repository_error",
+                error=str(e),
+                error_type=type(e).__name__,
+                severity="config_error",
+            )
+            self.console.print()
+            self.console.print(
+                "Make sure you're in a git repository directory",
+                style="dim",
+            )
+        except Exception as e:
+            self.console.print(
+                f"❌ Connectivity test failed: {e}",
+                style="bold red",
+            )
+            logger.error(
+                "git_connectivity_error",
+                error=str(e),
+                severity="infrastructure",
+                error_type=type(e).__name__,
+            )

roadmap/adapters/cli/git/handlers/git_hooks_handler.py

@@ -0,0 +1,105 @@
+"""Handler for Git hooks management."""
+
+import structlog
+from rich.console import Console
+
+from roadmap.adapters.git.git_hooks_manager import GitHookManager
+from roadmap.infrastructure.coordination.core import RoadmapCore
+
+logger = structlog.get_logger()
+
+
+class GitHooksHandler:
+    """Handles Git hooks installation, removal, and status checking."""
+
+    def __init__(self, console: Console):
+        """Initialize handler with console for output.
+
+        Args:
+            console: Rich Console instance
+        """
+        self.console = console
+
+    def install_hooks(self, core: RoadmapCore):
+        """Install Git hooks for roadmap integration.
+
+        Args:
+            core: RoadmapCore instance
+
+        Raises:
+            Exception: If hook installation fails
+        """
+        try:
+            manager = GitHookManager(core)
+            if manager.install_hooks():
+                self.console.print(
+                    "✅ Git hooks installed successfully", style="bold green"
+                )
+                self.console.print(
+                    "Hooks will now automatically track commits and branch changes",
+                    style="green",
+                )
+            else:
+                self.console.print(
+                    "❌ Failed to install hooks. Not a git repository?",
+                    style="bold red",
+                )
+        except Exception as e:
+            self.console.print(f"❌ Error installing hooks: {e}", style="bold red")
+            raise
+
+    def uninstall_hooks(self, core: RoadmapCore):
+        """Remove Git hooks for roadmap integration.
+
+        Args:
+            core: RoadmapCore instance
+
+        Raises:
+            Exception: If hook removal fails
+        """
+        try:
+            manager = GitHookManager(core)
+            if manager.uninstall_hooks():
+                self.console.print(
+                    "✅ Git hooks removed successfully", style="bold green"
+                )
+            else:
+                self.console.print("❌ Failed to remove hooks", style="bold red")
+        except Exception as e:
+            self.console.print(f"❌ Error removing hooks: {e}", style="bold red")
+            raise
+
+    def show_hooks_status(self, core: RoadmapCore):
+        """Show status of installed Git hooks.
+
+        Args:
+            core: RoadmapCore instance
+
+        Raises:
+            Exception: If status check fails
+        """
+        try:
+            manager = GitHookManager(core)
+            status = manager.get_hooks_status()
+
+            if not status:
+                self.console.print("No hooks installed", style="yellow")
+                return
+
+            self.console.print("Git Hooks Status:", style="bold")
+            self.console.print()
+
+            for hook_name, hook_info in status.items():
+                installed = "✅" if hook_info.get("is_roadmap_hook") else "❌"
+                executable = "✓" if hook_info.get("executable") else "✗"
+                self.console.print(
+                    f"{installed} {hook_name:20} [executable: {executable}]"
+                )
+
+            self.console.print()
+            self.console.print(
+                "Run 'roadmap git hooks-install' to install all hooks", style="dim"
+            )
+        except Exception as e:
+            self.console.print(f"❌ Error checking hooks: {e}", style="bold red")
+            raise