draft-board 0.1.0-beta.0

package/app/backend/app/routers/pull_requests.py

@@ -0,0 +1,382 @@
+"""Pull Request router for GitHub integration."""
+
+from datetime import datetime
+from pathlib import Path
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.exceptions import ConfigurationError
+from app.models.ticket import Ticket
+from app.models.ticket_event import TicketEvent
+from app.models.workspace import Workspace
+from app.services.git_host import get_git_host_provider
+from app.state_machine import ActorType, EventType, TicketState, validate_transition
+
+router = APIRouter(prefix="/pull-requests", tags=["pull-requests"])
+
+
+class CreatePRRequest(BaseModel):
+    """Request to create a GitHub Pull Request."""
+
+    ticket_id: str
+    title: str | None = None
+    body: str | None = None
+    base_branch: str = "main"
+
+
+class PRStatusResponse(BaseModel):
+    """Response with PR status information."""
+
+    pr_number: int
+    pr_url: str
+    pr_state: str
+    pr_created_at: datetime | None
+    pr_merged_at: datetime | None
+    pr_head_branch: str | None
+    pr_base_branch: str | None
+
+
+class AddPRCommentRequest(BaseModel):
+    """Request to add a comment to a PR."""
+
+    body: str
+
+
+class PRCommentResponse(BaseModel):
+    """A single PR comment."""
+
+    author: str
+    body: str
+    created_at: str
+
+
+class MergePRRequest(BaseModel):
+    """Request to merge a PR."""
+
+    strategy: str = "squash"  # squash, merge, rebase
+
+
+@router.post("", response_model=PRStatusResponse)
+async def create_pull_request(
+    request: CreatePRRequest,
+    db: AsyncSession = Depends(get_db),
+):
+    """
+    Create a GitHub Pull Request for a ticket.
+
+    This will:
+    1. Get the ticket and its workspace
+    2. Push the workspace branch to remote
+    3. Create a PR using GitHub CLI
+    4. Update ticket with PR information
+    5. Transition ticket to REVIEW state
+    """
+    # Get ticket
+    result = await db.execute(select(Ticket).where(Ticket.id == request.ticket_id))
+    ticket = result.scalar_one_or_none()
+
+    if not ticket:
+        raise HTTPException(
+            status_code=404, detail=f"Ticket {request.ticket_id} not found"
+        )
+
+    # Check if PR already exists
+    if ticket.pr_number:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Ticket already has PR #{ticket.pr_number}: {ticket.pr_url}",
+        )
+
+    # Get workspace
+    result = await db.execute(
+        select(Workspace).where(Workspace.ticket_id == request.ticket_id)
+    )
+    workspace = result.scalar_one_or_none()
+
+    if not workspace:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Ticket {request.ticket_id} has no workspace. Cannot create PR.",
+        )
+
+    if not workspace.worktree_path:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Workspace for ticket {request.ticket_id} has no worktree path.",
+        )
+
+    repo_path = Path(workspace.worktree_path)
+
+    if not repo_path.exists():
+        raise HTTPException(
+            status_code=400,
+            detail=f"Workspace path does not exist: {workspace.worktree_path}",
+        )
+
+    # Determine branch name
+    head_branch = workspace.branch_name or f"ticket-{ticket.id[:8]}"
+
+    # Use provided title/body or generate defaults
+    pr_title = request.title or ticket.title
+    pr_body = request.body or (
+        f"Implements: {ticket.title}\n\n"
+        f"{ticket.description or ''}\n\n"
+        f"Ticket ID: {ticket.id}"
+    )
+
+    # Get git host provider (auto-detects GitHub vs GitLab)
+    git_host = get_git_host_provider(repo_path)
+
+    try:
+        # Check if authenticated
+        await git_host.ensure_authenticated()
+
+        # Create PR/MR
+        pr = await git_host.create_pr(
+            repo_path=repo_path,
+            title=pr_title,
+            body=pr_body,
+            head_branch=head_branch,
+            base_branch=request.base_branch,
+        )
+
+        # Update ticket with PR information
+        ticket.pr_number = pr.number
+        ticket.pr_url = pr.url
+        ticket.pr_state = pr.state
+        ticket.pr_created_at = datetime.now()
+        ticket.pr_head_branch = pr.head_branch
+        ticket.pr_base_branch = pr.base_branch
+
+        await db.commit()
+        await db.refresh(ticket)
+
+        return PRStatusResponse(
+            pr_number=ticket.pr_number,
+            pr_url=ticket.pr_url,
+            pr_state=ticket.pr_state,
+            pr_created_at=ticket.pr_created_at,
+            pr_merged_at=ticket.pr_merged_at,
+            pr_head_branch=ticket.pr_head_branch,
+            pr_base_branch=ticket.pr_base_branch,
+        )
+
+    except ConfigurationError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except RuntimeError as e:
+        raise HTTPException(status_code=500, detail=f"Failed to create PR: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+
+
+@router.get("/{ticket_id}", response_model=PRStatusResponse)
+async def get_pr_status(
+    ticket_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    """Get the PR status for a ticket."""
+    result = await db.execute(select(Ticket).where(Ticket.id == ticket_id))
+    ticket = result.scalar_one_or_none()
+
+    if not ticket:
+        raise HTTPException(status_code=404, detail=f"Ticket {ticket_id} not found")
+
+    if not ticket.pr_number:
+        raise HTTPException(
+            status_code=404, detail=f"Ticket {ticket_id} has no associated PR"
+        )
+
+    return PRStatusResponse(
+        pr_number=ticket.pr_number,
+        pr_url=ticket.pr_url,
+        pr_state=ticket.pr_state,
+        pr_created_at=ticket.pr_created_at,
+        pr_merged_at=ticket.pr_merged_at,
+        pr_head_branch=ticket.pr_head_branch,
+        pr_base_branch=ticket.pr_base_branch,
+    )
+
+
+@router.post("/{ticket_id}/refresh", response_model=PRStatusResponse)
+async def refresh_pr_status(
+    ticket_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    """
+    Manually refresh the PR status from GitHub.
+
+    This will fetch the latest PR state from GitHub and update the ticket.
+    """
+    result = await db.execute(select(Ticket).where(Ticket.id == ticket_id))
+    ticket = result.scalar_one_or_none()
+
+    if not ticket:
+        raise HTTPException(status_code=404, detail=f"Ticket {ticket_id} not found")
+
+    if not ticket.pr_number:
+        raise HTTPException(
+            status_code=404, detail=f"Ticket {ticket_id} has no associated PR"
+        )
+
+    # Get workspace for repo path
+    result = await db.execute(select(Workspace).where(Workspace.ticket_id == ticket_id))
+    workspace = result.scalar_one_or_none()
+
+    if not workspace or not workspace.worktree_path:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot refresh PR status: workspace not found or no worktree path",
+        )
+
+    repo_path = Path(workspace.worktree_path)
+
+    try:
+        git_host = get_git_host_provider(repo_path)
+        pr_details = await git_host.get_pr_details(repo_path, ticket.pr_number)
+
+        # Update ticket
+        old_state = ticket.pr_state
+        ticket.pr_state = pr_details["state"]
+
+        if pr_details.get("merged") and not ticket.pr_merged_at:
+            ticket.pr_merged_at = datetime.now()
+
+        # Auto-transition ticket if PR was merged
+        if pr_details.get("merged") and old_state != "MERGED":
+            ticket.pr_state = "MERGED"
+            current_state = TicketState(ticket.state)
+            if validate_transition(current_state, TicketState.DONE):
+                ticket.state = TicketState.DONE.value
+                event = TicketEvent(
+                    ticket_id=ticket.id,
+                    event_type=EventType.TRANSITIONED.value,
+                    from_state=current_state.value,
+                    to_state=TicketState.DONE.value,
+                    actor_type=ActorType.SYSTEM.value,
+                    actor_id="pr_refresh",
+                    reason="PR merged on remote",
+                )
+                db.add(event)
+
+        await db.commit()
+        await db.refresh(ticket)
+
+        return PRStatusResponse(
+            pr_number=ticket.pr_number,
+            pr_url=ticket.pr_url,
+            pr_state=ticket.pr_state,
+            pr_created_at=ticket.pr_created_at,
+            pr_merged_at=ticket.pr_merged_at,
+            pr_head_branch=ticket.pr_head_branch,
+            pr_base_branch=ticket.pr_base_branch,
+        )
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to refresh PR status: {str(e)}"
+        )
+
+
+# ===================== PR Comment Endpoints =====================
+
+
+async def _get_ticket_with_pr(ticket_id: str, db: AsyncSession) -> tuple:
+    """Get ticket with PR info and workspace repo path."""
+    result = await db.execute(select(Ticket).where(Ticket.id == ticket_id))
+    ticket = result.scalar_one_or_none()
+    if not ticket:
+        raise HTTPException(status_code=404, detail=f"Ticket {ticket_id} not found")
+    if not ticket.pr_number:
+        raise HTTPException(status_code=400, detail="Ticket has no associated PR")
+
+    result = await db.execute(select(Workspace).where(Workspace.ticket_id == ticket_id))
+    workspace = result.scalar_one_or_none()
+    if not workspace or not workspace.worktree_path:
+        raise HTTPException(status_code=400, detail="No workspace found for ticket")
+
+    repo_path = Path(workspace.worktree_path)
+    return ticket, repo_path
+
+
+@router.post("/{ticket_id}/comments", response_model=dict)
+async def add_pr_comment(
+    ticket_id: str,
+    request: AddPRCommentRequest,
+    db: AsyncSession = Depends(get_db),
+):
+    """Add a comment to a ticket's PR."""
+    ticket, repo_path = await _get_ticket_with_pr(ticket_id, db)
+    git_host = get_git_host_provider(repo_path)
+
+    try:
+        result = await git_host.add_pr_comment(
+            repo_path, ticket.pr_number, request.body
+        )
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to add comment: {str(e)}")
+
+
+@router.get("/{ticket_id}/comments", response_model=list[PRCommentResponse])
+async def list_pr_comments(
+    ticket_id: str,
+    db: AsyncSession = Depends(get_db),
+):
+    """List all comments on a ticket's PR."""
+    ticket, repo_path = await _get_ticket_with_pr(ticket_id, db)
+    git_host = get_git_host_provider(repo_path)
+
+    try:
+        comments = await git_host.list_pr_comments(repo_path, ticket.pr_number)
+        return [
+            PRCommentResponse(
+                author=c.get("author", {}).get("login", "unknown"),
+                body=c.get("body", ""),
+                created_at=c.get("createdAt", ""),
+            )
+            for c in comments
+        ]
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to list comments: {str(e)}"
+        )
+
+
+@router.post("/{ticket_id}/merge", response_model=dict)
+async def merge_pr_endpoint(
+    ticket_id: str,
+    request: MergePRRequest,
+    db: AsyncSession = Depends(get_db),
+):
+    """Merge a ticket's PR on GitHub with the given strategy."""
+    ticket, repo_path = await _get_ticket_with_pr(ticket_id, db)
+    git_host = get_git_host_provider(repo_path)
+
+    try:
+        result = await git_host.merge_pr(repo_path, ticket.pr_number, request.strategy)
+
+        # Update ticket state on successful merge
+        ticket.pr_state = "MERGED"
+        ticket.pr_merged_at = datetime.now()
+        current_state = TicketState(ticket.state)
+        if validate_transition(current_state, TicketState.DONE):
+            ticket.state = TicketState.DONE.value
+            event = TicketEvent(
+                ticket_id=ticket.id,
+                event_type=EventType.TRANSITIONED.value,
+                from_state=current_state.value,
+                to_state=TicketState.DONE.value,
+                actor_type=ActorType.SYSTEM.value,
+                actor_id="pr_merge",
+                reason="PR merged",
+            )
+            db.add(event)
+        await db.commit()
+
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to merge PR: {str(e)}")

package/app/backend/app/routers/repos.py

@@ -0,0 +1,263 @@
+"""API router for Repository endpoints."""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.schemas.repo import (
+    DiscoveredRepoResponse,
+    DiscoverReposRequest,
+    DiscoverReposResponse,
+    RepoCreate,
+    RepoListResponse,
+    RepoResponse,
+    RepoUpdate,
+    ValidateRepoRequest,
+    ValidateRepoResponse,
+)
+from app.services.repo_discovery_service import RepoDiscoveryService
+
+router = APIRouter(prefix="/repos", tags=["repos"])
+
+
+# ============================================================================
+# Repo CRUD endpoints
+# ============================================================================
+
+
+@router.post(
+    "",
+    response_model=RepoResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Register a new repository",
+)
+async def create_repo(
+    data: RepoCreate,
+    db: AsyncSession = Depends(get_db),
+) -> RepoResponse:
+    """
+    Register a new git repository in the global registry.
+
+    **Validation:**
+    - Path must exist and be a directory
+    - Path must be a valid git repository
+    - Path must not already be registered
+
+    **Metadata:**
+    - Repository name derived from path if not provided
+    - Git metadata (default branch, remote URL) auto-detected
+    """
+    service = RepoDiscoveryService(db)
+    try:
+        repo = await service.register_repo(
+            path=data.path,
+            display_name=data.display_name,
+            setup_script=data.setup_script,
+            cleanup_script=data.cleanup_script,
+            dev_server_script=data.dev_server_script,
+        )
+        return RepoResponse.model_validate(repo)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get(
+    "",
+    response_model=RepoListResponse,
+    summary="List all registered repositories",
+)
+async def list_repos(
+    db: AsyncSession = Depends(get_db),
+) -> RepoListResponse:
+    """Get all registered repositories, ordered by creation date (newest first)."""
+    service = RepoDiscoveryService(db)
+    repos = await service.get_all_repos()
+    return RepoListResponse(
+        repos=[RepoResponse.model_validate(r) for r in repos],
+        total=len(repos),
+    )
+
+
+@router.get(
+    "/{repo_id}",
+    response_model=RepoResponse,
+    summary="Get a repository by ID",
+)
+async def get_repo(
+    repo_id: str,
+    db: AsyncSession = Depends(get_db),
+) -> RepoResponse:
+    """Get a repository by its ID."""
+    service = RepoDiscoveryService(db)
+    repo = await service.get_repo_by_id(repo_id)
+    if not repo:
+        raise HTTPException(status_code=404, detail=f"Repo not found: {repo_id}")
+    return RepoResponse.model_validate(repo)
+
+
+@router.patch(
+    "/{repo_id}",
+    response_model=RepoResponse,
+    summary="Update a repository",
+)
+async def update_repo(
+    repo_id: str,
+    data: RepoUpdate,
+    db: AsyncSession = Depends(get_db),
+) -> RepoResponse:
+    """
+    Update a repository's configuration.
+
+    **Updatable fields:**
+    - display_name - User-friendly name
+    - setup_script - Optional setup script
+    - cleanup_script - Optional cleanup script
+    - dev_server_script - Optional dev server script
+
+    **Note:** Path and git metadata are read-only.
+    """
+    service = RepoDiscoveryService(db)
+    try:
+        repo = await service.update_repo(
+            repo_id=repo_id,
+            display_name=data.display_name,
+            setup_script=data.setup_script,
+            cleanup_script=data.cleanup_script,
+            dev_server_script=data.dev_server_script,
+        )
+        return RepoResponse.model_validate(repo)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.delete(
+    "/{repo_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Delete a repository",
+)
+async def delete_repo(
+    repo_id: str,
+    db: AsyncSession = Depends(get_db),
+) -> None:
+    """
+    Delete a repository from the global registry.
+
+    **Warning:** This will cascade delete all BoardRepo associations.
+    Boards using this repo will no longer have it available.
+    """
+    service = RepoDiscoveryService(db)
+    try:
+        await service.delete_repo(repo_id)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+# ============================================================================
+# Discovery endpoints
+# ============================================================================
+
+
+@router.post(
+    "/discover",
+    response_model=DiscoverReposResponse,
+    summary="Discover git repositories",
+)
+async def discover_repos(
+    request: DiscoverReposRequest,
+    db: AsyncSession = Depends(get_db),
+) -> DiscoverReposResponse:
+    """
+    Scan directories for git repositories.
+
+    **How it works:**
+    1. Walks directory tree up to `max_depth` levels
+    2. Excludes common non-repo directories (node_modules, venv, etc.)
+    3. Detects .git directories
+    4. Extracts git metadata (branch, remote)
+    5. Returns list of discovered repos (not yet registered)
+
+    **Example:**
+    ```json
+    {
+      "search_paths": ["~/code", "~/projects"],
+      "max_depth": 3,
+      "exclude_patterns": ["archive", "old"]
+    }
+    ```
+
+    **Next steps:**
+    - Review discovered repos
+    - Use POST /repos to register desired repos
+    """
+    service = RepoDiscoveryService(db)
+
+    exclude_set = set(request.exclude_patterns) if request.exclude_patterns else None
+
+    discovered = await service.discover_repos(
+        search_paths=request.search_paths,
+        max_depth=request.max_depth,
+        exclude_patterns=exclude_set,
+    )
+
+    return DiscoverReposResponse(
+        discovered=[
+            DiscoveredRepoResponse(
+                path=r.path,
+                name=r.name,
+                display_name=r.display_name,
+                default_branch=r.default_branch,
+                remote_url=r.remote_url,
+                is_valid=r.is_valid,
+                error_message=r.error_message,
+            )
+            for r in discovered
+        ],
+        total=len(discovered),
+    )
+
+
+@router.post(
+    "/validate",
+    response_model=ValidateRepoResponse,
+    summary="Validate a repository path",
+)
+async def validate_repo(
+    request: ValidateRepoRequest,
+    db: AsyncSession = Depends(get_db),
+) -> ValidateRepoResponse:
+    """
+    Validate that a path is a valid git repository.
+
+    **Checks:**
+    - Path exists
+    - Path is a directory
+    - Path contains a .git directory
+    - Git repository is accessible
+
+    **Returns:**
+    - is_valid: Whether path is a valid repo
+    - path: Normalized absolute path
+    - metadata: Git metadata if valid
+    - error_message: Error description if invalid
+    """
+    service = RepoDiscoveryService(db)
+    validation = await service.validate_repo_path(request.path)
+
+    metadata_response = None
+    if validation.metadata:
+        metadata_response = DiscoveredRepoResponse(
+            path=validation.metadata.path,
+            name=validation.metadata.name,
+            display_name=validation.metadata.display_name,
+            default_branch=validation.metadata.default_branch,
+            remote_url=validation.metadata.remote_url,
+            is_valid=validation.metadata.is_valid,
+            error_message=validation.metadata.error_message,
+        )
+
+    return ValidateRepoResponse(
+        is_valid=validation.is_valid,
+        path=validation.path,
+        error_message=validation.error_message,
+        metadata=metadata_response,
+    )