draft-board 0.1.0-beta.0

package/app/backend/app/services/git_host/factory.py

@@ -0,0 +1,87 @@
+"""Factory for creating git host providers with auto-detection."""
+
+import logging
+import subprocess
+from pathlib import Path
+
+from app.services.git_host.github import GitHubProvider
+from app.services.git_host.gitlab import GitLabProvider
+from app.services.git_host.protocol import GitHostProvider
+
+logger = logging.getLogger(__name__)
+
+# Cached providers by repo path
+_providers: dict[str, GitHostProvider] = {}
+
+
+def detect_git_host(repo_path: Path | None = None) -> str:
+    """Detect the git host from the remote URL.
+
+    Args:
+        repo_path: Path to a git repository. If None, uses cwd.
+
+    Returns:
+        'github', 'gitlab', or 'unknown'
+    """
+    try:
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            cwd=repo_path or ".",
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            return "unknown"
+
+        url = result.stdout.strip().lower()
+
+        if "github.com" in url or "github" in url:
+            return "github"
+        elif "gitlab.com" in url or "gitlab" in url:
+            return "gitlab"
+        else:
+            return "unknown"
+
+    except Exception as e:
+        logger.debug(f"Failed to detect git host: {e}")
+        return "unknown"
+
+
+def get_git_host_provider(
+    repo_path: Path | None = None,
+    force_provider: str | None = None,
+) -> GitHostProvider:
+    """Get a git host provider, auto-detecting from the remote URL.
+
+    Args:
+        repo_path: Path to a git repository for detection.
+        force_provider: Force a specific provider ('github' or 'gitlab').
+
+    Returns:
+        A GitHostProvider instance.
+
+    Raises:
+        ValueError: If the host cannot be determined or is unsupported.
+    """
+    cache_key = force_provider or str(repo_path or "default")
+
+    if cache_key in _providers:
+        return _providers[cache_key]
+
+    host = force_provider or detect_git_host(repo_path)
+
+    if host == "github":
+        provider = GitHubProvider()
+    elif host == "gitlab":
+        provider = GitLabProvider()
+    else:
+        # Default to GitHub (most common) but log a warning
+        logger.warning(
+            f"Could not detect git host (got '{host}'), defaulting to GitHub. "
+            "Set force_provider='gitlab' if using GitLab."
+        )
+        provider = GitHubProvider()
+
+    _providers[cache_key] = provider
+    return provider

package/app/backend/app/services/git_host/github.py

@@ -0,0 +1,270 @@
+"""GitHub provider implementation using gh CLI."""
+
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from app.exceptions import ConfigurationError
+from app.services.git_host.protocol import PullRequest
+
+
+class GitHubProvider:
+    """GitHub provider using the gh CLI."""
+
+    def __init__(self) -> None:
+        self._gh_path: str | None = None
+        self._authenticated: bool | None = None
+
+    @property
+    def name(self) -> str:
+        return "github"
+
+    @property
+    def gh_path(self) -> str:
+        if self._gh_path is None:
+            self._gh_path = shutil.which("gh")
+            if not self._gh_path:
+                raise ConfigurationError(
+                    "GitHub CLI (gh) not found. Install from https://cli.github.com/"
+                )
+        return self._gh_path
+
+    def is_available(self) -> bool:
+        try:
+            return bool(shutil.which("gh"))
+        except Exception:
+            return False
+
+    async def is_authenticated(self) -> bool:
+        if self._authenticated is not None:
+            return self._authenticated
+        try:
+            result = subprocess.run(
+                [self.gh_path, "auth", "status"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            self._authenticated = result.returncode == 0
+            return self._authenticated
+        except Exception:
+            self._authenticated = False
+            return False
+
+    async def ensure_authenticated(self) -> None:
+        if not await self.is_authenticated():
+            raise ConfigurationError(
+                "Not authenticated with GitHub. Run 'gh auth login' first."
+            )
+
+    async def create_pr(
+        self,
+        repo_path: Path,
+        title: str,
+        body: str,
+        head_branch: str,
+        base_branch: str,
+    ) -> PullRequest:
+        await self.ensure_authenticated()
+
+        # Push branch to remote first (required for PR creation)
+        from app.services.git_ops import push_branch
+
+        push_result = push_branch(repo_path, head_branch)
+        if not push_result.success:
+            raise RuntimeError(
+                f"Failed to push branch before PR creation: {push_result.message}"
+            )
+
+        cmd = [
+            self.gh_path,
+            "pr",
+            "create",
+            "--title",
+            title,
+            "--body",
+            body,
+            "--base",
+            base_branch,
+            "--head",
+            head_branch,
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=30
+            )
+
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to create PR: {result.stderr.strip()}")
+
+            pr_url = result.stdout.strip()
+            pr_number_match = re.search(r"/pull/(\d+)", pr_url)
+            if not pr_number_match:
+                raise RuntimeError(f"Could not extract PR number from URL: {pr_url}")
+
+            return PullRequest(
+                number=int(pr_number_match.group(1)),
+                url=pr_url,
+                title=title,
+                state="OPEN",
+                head_branch=head_branch,
+                base_branch=base_branch,
+                merged=False,
+            )
+
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("PR creation timed out after 30 seconds")
+        except RuntimeError:
+            raise
+        except Exception as e:
+            raise RuntimeError(f"Failed to create PR: {e}")
+
+    async def get_pr_status(self, repo_path: Path, pr_number: int) -> str:
+        await self.ensure_authenticated()
+
+        cmd = [
+            self.gh_path,
+            "pr",
+            "view",
+            str(pr_number),
+            "--json",
+            "state",
+            "--jq",
+            ".state",
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=10
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to get PR status: {result.stderr}")
+            return result.stdout.strip()
+        except Exception as e:
+            raise RuntimeError(f"Failed to get PR status: {e}")
+
+    async def get_pr_details(self, repo_path: Path, pr_number: int) -> dict[str, any]:
+        await self.ensure_authenticated()
+
+        cmd = [
+            self.gh_path,
+            "pr",
+            "view",
+            str(pr_number),
+            "--json",
+            "number,title,state,url,headRefName,baseRefName,merged",
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=10
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to get PR details: {result.stderr}")
+            return json.loads(result.stdout)
+        except Exception as e:
+            raise RuntimeError(f"Failed to get PR details: {e}")
+
+    async def add_pr_comment(self, repo_path: Path, pr_number: int, body: str) -> dict:
+        """Add a comment to a PR."""
+        await self.ensure_authenticated()
+
+        cmd = [
+            self.gh_path,
+            "pr",
+            "comment",
+            str(pr_number),
+            "--body",
+            body,
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=15
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to add PR comment: {result.stderr.strip()}")
+            return {"success": True, "message": "Comment added"}
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("PR comment timed out")
+        except RuntimeError:
+            raise
+        except Exception as e:
+            raise RuntimeError(f"Failed to add PR comment: {e}")
+
+    async def list_pr_comments(self, repo_path: Path, pr_number: int) -> list[dict]:
+        """List comments on a PR."""
+        await self.ensure_authenticated()
+
+        cmd = [
+            self.gh_path,
+            "pr",
+            "view",
+            str(pr_number),
+            "--json",
+            "comments",
+            "--jq",
+            ".comments",
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=10
+            )
+            if result.returncode != 0:
+                raise RuntimeError(
+                    f"Failed to list PR comments: {result.stderr.strip()}"
+                )
+            return json.loads(result.stdout) if result.stdout.strip() else []
+        except Exception as e:
+            raise RuntimeError(f"Failed to list PR comments: {e}")
+
+    async def merge_pr(
+        self,
+        repo_path: Path,
+        pr_number: int,
+        strategy: str = "squash",
+    ) -> dict:
+        """Merge a PR with the given strategy.
+
+        Args:
+            repo_path: Repo path for gh CLI context
+            pr_number: PR number to merge
+            strategy: One of 'squash', 'merge', 'rebase'
+        """
+        await self.ensure_authenticated()
+
+        strategy_flag = {
+            "squash": "--squash",
+            "merge": "--merge",
+            "rebase": "--rebase",
+        }.get(strategy, "--squash")
+
+        cmd = [
+            self.gh_path,
+            "pr",
+            "merge",
+            str(pr_number),
+            strategy_flag,
+            "--delete-branch",
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=30
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to merge PR: {result.stderr.strip()}")
+            return {
+                "success": True,
+                "message": f"PR #{pr_number} merged via {strategy}",
+            }
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("PR merge timed out after 30 seconds")
+        except RuntimeError:
+            raise
+        except Exception as e:
+            raise RuntimeError(f"Failed to merge PR: {e}")

package/app/backend/app/services/git_host/gitlab.py

@@ -0,0 +1,194 @@
+"""GitLab provider implementation using glab CLI."""
+
+import json
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from app.exceptions import ConfigurationError
+from app.services.git_host.protocol import PullRequest
+
+
+class GitLabProvider:
+    """GitLab provider using the glab CLI."""
+
+    def __init__(self) -> None:
+        self._glab_path: str | None = None
+        self._authenticated: bool | None = None
+
+    @property
+    def name(self) -> str:
+        return "gitlab"
+
+    @property
+    def glab_path(self) -> str:
+        if self._glab_path is None:
+            self._glab_path = shutil.which("glab")
+            if not self._glab_path:
+                raise ConfigurationError(
+                    "GitLab CLI (glab) not found. "
+                    "Install from https://gitlab.com/gitlab-org/cli"
+                )
+        return self._glab_path
+
+    def is_available(self) -> bool:
+        try:
+            return bool(shutil.which("glab"))
+        except Exception:
+            return False
+
+    async def is_authenticated(self) -> bool:
+        if self._authenticated is not None:
+            return self._authenticated
+        try:
+            result = subprocess.run(
+                [self.glab_path, "auth", "status"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            self._authenticated = result.returncode == 0
+            return self._authenticated
+        except Exception:
+            self._authenticated = False
+            return False
+
+    async def ensure_authenticated(self) -> None:
+        if not await self.is_authenticated():
+            raise ConfigurationError(
+                "Not authenticated with GitLab. Run 'glab auth login' first."
+            )
+
+    async def create_pr(
+        self,
+        repo_path: Path,
+        title: str,
+        body: str,
+        head_branch: str,
+        base_branch: str,
+    ) -> PullRequest:
+        await self.ensure_authenticated()
+
+        cmd = [
+            self.glab_path,
+            "mr",
+            "create",
+            "--title",
+            title,
+            "--description",
+            body,
+            "--target-branch",
+            base_branch,
+            "--source-branch",
+            head_branch,
+            "--no-editor",
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=30
+            )
+
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to create MR: {result.stderr.strip()}")
+
+            mr_url = result.stdout.strip()
+            # Extract MR number from URL like https://gitlab.com/org/repo/-/merge_requests/123
+            mr_number_match = re.search(r"/merge_requests/(\d+)", mr_url)
+            if not mr_number_match:
+                # Try to find it in any line
+                for line in mr_url.split("\n"):
+                    mr_number_match = re.search(r"/merge_requests/(\d+)", line)
+                    if mr_number_match:
+                        mr_url = line.strip()
+                        break
+
+            if not mr_number_match:
+                raise RuntimeError(f"Could not extract MR number from output: {mr_url}")
+
+            return PullRequest(
+                number=int(mr_number_match.group(1)),
+                url=mr_url,
+                title=title,
+                state="OPEN",
+                head_branch=head_branch,
+                base_branch=base_branch,
+                merged=False,
+            )
+
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("MR creation timed out after 30 seconds")
+        except RuntimeError:
+            raise
+        except Exception as e:
+            raise RuntimeError(f"Failed to create MR: {e}")
+
+    async def get_pr_status(self, repo_path: Path, pr_number: int) -> str:
+        await self.ensure_authenticated()
+
+        cmd = [
+            self.glab_path,
+            "mr",
+            "view",
+            str(pr_number),
+            "--output",
+            "json",
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=10
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to get MR status: {result.stderr}")
+
+            data = json.loads(result.stdout)
+            state = data.get("state", "").upper()
+            if state == "MERGED":
+                return "MERGED"
+            elif state == "CLOSED":
+                return "CLOSED"
+            return "OPEN"
+        except Exception as e:
+            raise RuntimeError(f"Failed to get MR status: {e}")
+
+    async def get_pr_details(self, repo_path: Path, pr_number: int) -> dict[str, any]:
+        await self.ensure_authenticated()
+
+        cmd = [
+            self.glab_path,
+            "mr",
+            "view",
+            str(pr_number),
+            "--output",
+            "json",
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd, cwd=repo_path, capture_output=True, text=True, timeout=10
+            )
+            if result.returncode != 0:
+                raise RuntimeError(f"Failed to get MR details: {result.stderr}")
+
+            data = json.loads(result.stdout)
+            # Normalize to the same shape as GitHub
+            state = data.get("state", "").upper()
+            merged = state == "MERGED"
+            if not merged and state == "CLOSED":
+                pass  # keep as CLOSED
+            elif not merged:
+                state = "OPEN"
+
+            return {
+                "number": data.get("iid", pr_number),
+                "title": data.get("title", ""),
+                "state": state,
+                "url": data.get("web_url", ""),
+                "headRefName": data.get("source_branch", ""),
+                "baseRefName": data.get("target_branch", ""),
+                "merged": merged,
+            }
+        except Exception as e:
+            raise RuntimeError(f"Failed to get MR details: {e}")

package/app/backend/app/services/git_host/protocol.py

@@ -0,0 +1,75 @@
+"""Git host provider protocol definition."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+
+@dataclass
+class PullRequest:
+    """Represents a pull/merge request."""
+
+    number: int
+    url: str
+    title: str
+    state: str  # 'OPEN', 'CLOSED', 'MERGED'
+    head_branch: str
+    base_branch: str
+    merged: bool = False
+
+
+@runtime_checkable
+class GitHostProvider(Protocol):
+    """Protocol for git hosting providers (GitHub, GitLab, etc.)."""
+
+    @property
+    def name(self) -> str:
+        """Provider name (e.g. 'github', 'gitlab')."""
+        ...
+
+    def is_available(self) -> bool:
+        """Check if the CLI tool for this provider is installed."""
+        ...
+
+    async def is_authenticated(self) -> bool:
+        """Check if the user is authenticated with this provider."""
+        ...
+
+    async def ensure_authenticated(self) -> None:
+        """Ensure user is authenticated, raise ConfigurationError if not."""
+        ...
+
+    async def create_pr(
+        self,
+        repo_path: Path,
+        title: str,
+        body: str,
+        head_branch: str,
+        base_branch: str,
+    ) -> PullRequest:
+        """Create a pull/merge request."""
+        ...
+
+    async def get_pr_status(self, repo_path: Path, pr_number: int) -> str:
+        """Get the status of a PR: 'OPEN', 'CLOSED', or 'MERGED'."""
+        ...
+
+    async def get_pr_details(self, repo_path: Path, pr_number: int) -> dict[str, any]:
+        """Get detailed information about a PR."""
+        ...
+
+    async def add_pr_comment(self, repo_path: Path, pr_number: int, body: str) -> dict:
+        """Add a comment to a PR."""
+        ...
+
+    async def list_pr_comments(self, repo_path: Path, pr_number: int) -> list[dict]:
+        """List comments on a PR."""
+        ...
+
+    async def merge_pr(
+        self, repo_path: Path, pr_number: int, strategy: str = "squash"
+    ) -> dict:
+        """Merge a PR with the given strategy (squash, merge, rebase)."""
+        ...