draft-board 0.1.0-beta.0

package/app/backend/app/services/repo_discovery_service.py

@@ -0,0 +1,318 @@
+"""Service for discovering and managing git repositories."""
+
+import os
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+
+import git
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.repo import Repo
+
+
+@dataclass
+class DiscoveredRepo:
+    """Represents a discovered git repository."""
+
+    path: str
+    name: str
+    display_name: str
+    default_branch: str | None = None
+    remote_url: str | None = None
+    is_valid: bool = True
+    error_message: str | None = None
+
+
+@dataclass
+class RepoValidation:
+    """Result of repository path validation."""
+
+    is_valid: bool
+    path: str
+    error_message: str | None = None
+    metadata: DiscoveredRepo | None = None
+
+
+class RepoDiscoveryService:
+    """Service to discover and register git repositories."""
+
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    # Patterns to exclude from discovery
+    EXCLUDE_PATTERNS = {
+        "node_modules",
+        ".git",
+        "vendor",
+        "venv",
+        ".venv",
+        "env",
+        "__pycache__",
+        ".pytest_cache",
+        "dist",
+        "build",
+        ".tox",
+        ".eggs",
+        "target",  # Rust
+        ".gradle",  # Gradle
+        ".mvn",  # Maven
+    }
+
+    async def discover_repos(
+        self,
+        search_paths: list[str],
+        max_depth: int = 3,
+        exclude_patterns: set[str] | None = None,
+    ) -> list[DiscoveredRepo]:
+        """
+        Scan directories for git repositories.
+
+        Args:
+            search_paths: List of directories to scan
+            max_depth: How deep to recurse (default 3)
+            exclude_patterns: Additional patterns to exclude
+
+        Returns:
+            List of discovered git repositories
+        """
+        if exclude_patterns is None:
+            exclude_patterns = self.EXCLUDE_PATTERNS.copy()
+        else:
+            exclude_patterns = self.EXCLUDE_PATTERNS | exclude_patterns
+
+        discovered = []
+
+        for search_path in search_paths:
+            # Expand user path (~)
+            expanded_path = os.path.expanduser(search_path)
+            path_obj = Path(expanded_path).resolve()
+
+            if not path_obj.exists():
+                continue
+
+            # Walk directory tree
+            for root, dirs, _ in os.walk(path_obj, topdown=True):
+                # Calculate current depth
+                rel_path = Path(root).relative_to(path_obj)
+                depth = len(rel_path.parts) if rel_path != Path(".") else 0
+
+                # Prune search if too deep
+                if depth >= max_depth:
+                    dirs.clear()
+                    continue
+
+                # Prune excluded directories
+                dirs[:] = [d for d in dirs if d not in exclude_patterns]
+
+                # Check if this directory is a git repo
+                git_dir = Path(root) / ".git"
+                if git_dir.exists():
+                    # Found a git repo
+                    repo_path = str(Path(root).resolve())
+                    validation = self._validate_repo_path_sync(repo_path)
+
+                    if validation.is_valid and validation.metadata:
+                        discovered.append(validation.metadata)
+
+                    # Don't recurse into git repos (avoid submodules)
+                    dirs.clear()
+
+        return discovered
+
+    async def validate_repo_path(self, path: str) -> RepoValidation:
+        """
+        Validate a path is a valid git repository.
+
+        Returns:
+            RepoValidation with is_valid, error_message, and metadata
+        """
+        return self._validate_repo_path_sync(path)
+
+    def _validate_repo_path_sync(self, path: str) -> RepoValidation:
+        """Synchronous version of validate_repo_path (for use in discover_repos)."""
+        try:
+            # Expand and resolve path
+            expanded = os.path.expanduser(path)
+            path_obj = Path(expanded).resolve()
+
+            # Check if path exists
+            if not path_obj.exists():
+                return RepoValidation(
+                    is_valid=False,
+                    path=str(path_obj),
+                    error_message=f"Path does not exist: {path_obj}",
+                )
+
+            # Check if it's a directory
+            if not path_obj.is_dir():
+                return RepoValidation(
+                    is_valid=False,
+                    path=str(path_obj),
+                    error_message=f"Path is not a directory: {path_obj}",
+                )
+
+            # Try to open as git repo
+            try:
+                repo = git.Repo(str(path_obj))
+            except git.InvalidGitRepositoryError:
+                return RepoValidation(
+                    is_valid=False,
+                    path=str(path_obj),
+                    error_message=f"Path is not a git repository: {path_obj}",
+                )
+
+            # Extract metadata
+            name = path_obj.name
+            display_name = name
+
+            # Get default branch
+            try:
+                default_branch = repo.active_branch.name
+            except Exception:
+                # Detached HEAD or other issue
+                default_branch = "main"
+
+            # Get remote URL
+            remote_url = None
+            try:
+                if repo.remotes:
+                    remote_url = repo.remotes.origin.url
+            except Exception:
+                pass
+
+            metadata = DiscoveredRepo(
+                path=str(path_obj),
+                name=name,
+                display_name=display_name,
+                default_branch=default_branch,
+                remote_url=remote_url,
+                is_valid=True,
+            )
+
+            return RepoValidation(
+                is_valid=True,
+                path=str(path_obj),
+                metadata=metadata,
+            )
+
+        except Exception as e:
+            return RepoValidation(
+                is_valid=False,
+                path=path,
+                error_message=f"Validation error: {str(e)}",
+            )
+
+    async def register_repo(
+        self,
+        path: str,
+        display_name: str | None = None,
+        setup_script: str | None = None,
+        cleanup_script: str | None = None,
+        dev_server_script: str | None = None,
+    ) -> Repo:
+        """
+        Register a repository in the global registry.
+
+        Args:
+            path: Filesystem path to git repository
+            display_name: Optional user-friendly name
+            setup_script: Optional setup script
+            cleanup_script: Optional cleanup script
+            dev_server_script: Optional dev server script
+
+        Returns:
+            Created Repo model
+
+        Raises:
+            ValueError: If path is invalid or repo already exists
+        """
+        # Validate path
+        validation = await self.validate_repo_path(path)
+        if not validation.is_valid:
+            raise ValueError(validation.error_message or "Invalid repository path")
+
+        if not validation.metadata:
+            raise ValueError("Repository validation returned no metadata")
+
+        # Check if repo already exists
+        result = await self.db.execute(select(Repo).where(Repo.path == validation.path))
+        existing = result.scalar_one_or_none()
+        if existing:
+            raise ValueError(f"Repository already registered: {validation.path}")
+
+        # Create repo
+        metadata = validation.metadata
+        repo = Repo(
+            id=str(uuid.uuid4()),
+            path=validation.path,
+            name=metadata.name,
+            display_name=display_name or metadata.display_name,
+            setup_script=setup_script,
+            cleanup_script=cleanup_script,
+            dev_server_script=dev_server_script,
+            default_branch=metadata.default_branch,
+            remote_url=metadata.remote_url,
+        )
+
+        self.db.add(repo)
+        await self.db.commit()
+        await self.db.refresh(repo)
+
+        return repo
+
+    async def get_repo_by_id(self, repo_id: str) -> Repo | None:
+        """Get a repo by its ID."""
+        result = await self.db.execute(select(Repo).where(Repo.id == repo_id))
+        return result.scalar_one_or_none()
+
+    async def get_repo_by_path(self, path: str) -> Repo | None:
+        """Get a repo by its path."""
+        # Normalize path
+        expanded = os.path.expanduser(path)
+        normalized = str(Path(expanded).resolve())
+
+        result = await self.db.execute(select(Repo).where(Repo.path == normalized))
+        return result.scalar_one_or_none()
+
+    async def get_all_repos(self) -> list[Repo]:
+        """Get all registered repos."""
+        result = await self.db.execute(select(Repo).order_by(Repo.created_at.desc()))
+        return list(result.scalars().all())
+
+    async def update_repo(
+        self,
+        repo_id: str,
+        display_name: str | None = None,
+        setup_script: str | None = None,
+        cleanup_script: str | None = None,
+        dev_server_script: str | None = None,
+    ) -> Repo:
+        """Update a repo's configuration."""
+        repo = await self.get_repo_by_id(repo_id)
+        if not repo:
+            raise ValueError(f"Repo not found: {repo_id}")
+
+        if display_name is not None:
+            repo.display_name = display_name
+        if setup_script is not None:
+            repo.setup_script = setup_script
+        if cleanup_script is not None:
+            repo.cleanup_script = cleanup_script
+        if dev_server_script is not None:
+            repo.dev_server_script = dev_server_script
+
+        await self.db.commit()
+        await self.db.refresh(repo)
+
+        return repo
+
+    async def delete_repo(self, repo_id: str) -> None:
+        """Delete a repo from the registry."""
+        repo = await self.get_repo_by_id(repo_id)
+        if not repo:
+            raise ValueError(f"Repo not found: {repo_id}")
+
+        await self.db.delete(repo)
+        await self.db.commit()

package/app/backend/app/services/review_service.py

@@ -0,0 +1,334 @@
+"""Service layer for Review operations (comments and summaries)."""
+
+import logging
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.exceptions import ResourceNotFoundError, ValidationError
+from app.models.review_comment import AuthorType, ReviewComment
+from app.models.review_summary import ReviewDecision, ReviewSummary
+from app.models.revision import Revision, RevisionStatus
+from app.schemas.review import FeedbackBundle, FeedbackComment
+from app.services.revision_service import compute_anchor
+
+logger = logging.getLogger(__name__)
+
+
+class ReviewService:
+    """Service class for Review business logic (comments and summaries)."""
+
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    # ==================== Comment Operations ====================
+
+    async def add_comment(
+        self,
+        revision_id: str,
+        file_path: str,
+        line_number: int,
+        body: str,
+        author_type: AuthorType = AuthorType.HUMAN,
+        hunk_header: str | None = None,
+        line_content: str | None = None,
+    ) -> ReviewComment:
+        """Add an inline comment to a revision.
+
+        Args:
+            revision_id: The UUID of the revision
+            file_path: Path to the file being commented on
+            line_number: Line number in the new file
+            body: Comment body text
+            author_type: Type of author (human, agent, system)
+            hunk_header: Optional diff hunk header for anchor computation
+            line_content: Optional line content for anchor computation
+
+        Returns:
+            The created ReviewComment instance
+
+        Raises:
+            ResourceNotFoundError: If revision not found
+            ConflictError: If revision is superseded
+        """
+        # Verify revision exists
+        result = await self.db.execute(
+            select(Revision).where(Revision.id == revision_id)
+        )
+        revision = result.scalar_one_or_none()
+        if revision is None:
+            raise ResourceNotFoundError("Revision", revision_id)
+
+        # Block comments on superseded revisions
+        if revision.status == RevisionStatus.SUPERSEDED.value:
+            from app.exceptions import ConflictError
+
+            raise ConflictError(
+                "Revision is superseded. Please review the latest revision."
+            )
+
+        # Compute anchor - use provided values or fallback
+        anchor = compute_anchor(
+            file_path=file_path,
+            hunk_header=hunk_header or "",
+            line_content=line_content or f"line:{line_number}",
+        )
+
+        comment = ReviewComment(
+            revision_id=revision_id,
+            file_path=file_path,
+            line_number=line_number,
+            anchor=anchor,
+            line_content=line_content,
+            body=body,
+            author_type=author_type.value,
+            resolved=False,
+        )
+        self.db.add(comment)
+        await self.db.flush()
+        await self.db.refresh(comment)
+
+        logger.info(
+            f"Added comment {comment.id} on revision {revision_id} at {file_path}:{line_number}"
+        )
+        return comment
+
+    async def get_comments_for_revision(
+        self, revision_id: str, include_resolved: bool = True
+    ) -> list[ReviewComment]:
+        """Get all comments for a revision.
+
+        Args:
+            revision_id: The UUID of the revision
+            include_resolved: Whether to include resolved comments
+
+        Returns:
+            List of ReviewComment instances ordered by creation time
+        """
+        # Verify revision exists
+        result = await self.db.execute(
+            select(Revision).where(Revision.id == revision_id)
+        )
+        if result.scalar_one_or_none() is None:
+            raise ResourceNotFoundError("Revision", revision_id)
+
+        query = select(ReviewComment).where(ReviewComment.revision_id == revision_id)
+
+        if not include_resolved:
+            query = query.where(ReviewComment.resolved == False)  # noqa: E712
+
+        query = query.order_by(ReviewComment.created_at.asc())
+
+        result = await self.db.execute(query)
+        return list(result.scalars().all())
+
+    async def get_comment_by_id(self, comment_id: str) -> ReviewComment:
+        """Get a comment by its ID.
+
+        Args:
+            comment_id: The UUID of the comment
+
+        Returns:
+            The ReviewComment instance
+
+        Raises:
+            ResourceNotFoundError: If the comment is not found
+        """
+        result = await self.db.execute(
+            select(ReviewComment).where(ReviewComment.id == comment_id)
+        )
+        comment = result.scalar_one_or_none()
+        if comment is None:
+            raise ResourceNotFoundError("ReviewComment", comment_id)
+        return comment
+
+    async def resolve_comment(self, comment_id: str) -> ReviewComment:
+        """Mark a comment as resolved.
+
+        Args:
+            comment_id: The UUID of the comment
+
+        Returns:
+            The updated ReviewComment instance
+        """
+        comment = await self.get_comment_by_id(comment_id)
+        comment.resolved = True
+        await self.db.flush()
+        await self.db.refresh(comment)
+        logger.info(f"Resolved comment {comment_id}")
+        return comment
+
+    async def unresolve_comment(self, comment_id: str) -> ReviewComment:
+        """Mark a comment as unresolved.
+
+        Args:
+            comment_id: The UUID of the comment
+
+        Returns:
+            The updated ReviewComment instance
+        """
+        comment = await self.get_comment_by_id(comment_id)
+        comment.resolved = False
+        await self.db.flush()
+        await self.db.refresh(comment)
+        logger.info(f"Unresolved comment {comment_id}")
+        return comment
+
+    async def get_unresolved_count(self, revision_id: str) -> int:
+        """Get the count of unresolved comments for a revision.
+
+        Args:
+            revision_id: The UUID of the revision
+
+        Returns:
+            Number of unresolved comments
+        """
+        result = await self.db.execute(
+            select(ReviewComment).where(
+                ReviewComment.revision_id == revision_id,
+                ReviewComment.resolved == False,  # noqa: E712
+            )
+        )
+        return len(list(result.scalars().all()))
+
+    # ==================== Review Summary Operations ====================
+
+    async def submit_review(
+        self,
+        revision_id: str,
+        decision: ReviewDecision,
+        summary: str,
+    ) -> ReviewSummary:
+        """Submit a review decision for a revision.
+
+        Args:
+            revision_id: The UUID of the revision
+            decision: The review decision (approved or changes_requested)
+            summary: High-level review feedback
+
+        Returns:
+            The created ReviewSummary instance
+
+        Raises:
+            ValidationError: If unresolved comments exist when approving
+            ConflictError: If revision is superseded
+        """
+        # Get revision with comments
+        result = await self.db.execute(
+            select(Revision)
+            .where(Revision.id == revision_id)
+            .options(
+                selectinload(Revision.comments),
+                selectinload(Revision.review_summary),
+            )
+        )
+        revision = result.scalar_one_or_none()
+        if revision is None:
+            raise ResourceNotFoundError("Revision", revision_id)
+
+        # Block reviews on superseded revisions
+        if revision.status == RevisionStatus.SUPERSEDED.value:
+            from app.exceptions import ConflictError
+
+            raise ConflictError(
+                "Revision is superseded. Please review the latest revision."
+            )
+
+        # Check if review already exists
+        if revision.review_summary:
+            raise ValidationError("This revision already has a review submitted")
+
+        # Note: We allow approval even with unresolved comments.
+        # Comments are informational notes; approving accepts the changes.
+        # Requesting changes sends all unresolved comments to the agent as feedback.
+
+        # Create the review summary
+        review_summary = ReviewSummary(
+            revision_id=revision_id,
+            decision=decision.value,
+            body=summary,
+        )
+        self.db.add(review_summary)
+
+        # Update revision status based on decision
+        if decision == ReviewDecision.APPROVED:
+            revision.status = RevisionStatus.APPROVED.value
+        else:
+            revision.status = RevisionStatus.CHANGES_REQUESTED.value
+
+        await self.db.flush()
+        await self.db.refresh(review_summary)
+
+        logger.info(f"Submitted review for revision {revision_id}: {decision.value}")
+        return review_summary
+
+    async def get_review_summary(self, revision_id: str) -> ReviewSummary | None:
+        """Get the review summary for a revision.
+
+        Args:
+            revision_id: The UUID of the revision
+
+        Returns:
+            The ReviewSummary instance or None if no review exists
+        """
+        result = await self.db.execute(
+            select(ReviewSummary).where(ReviewSummary.revision_id == revision_id)
+        )
+        return result.scalar_one_or_none()
+
+    # ==================== Feedback Bundle ====================
+
+    async def get_feedback_bundle(self, revision_id: str) -> FeedbackBundle:
+        """Get the feedback bundle for a revision.
+
+        This is the structured feedback that gets injected into the agent prompt
+        when creating a new revision after changes are requested.
+
+        Args:
+            revision_id: The UUID of the revision
+
+        Returns:
+            FeedbackBundle containing all review feedback
+        """
+        # Get revision with all related data
+        result = await self.db.execute(
+            select(Revision)
+            .where(Revision.id == revision_id)
+            .options(
+                selectinload(Revision.comments),
+                selectinload(Revision.review_summary),
+            )
+        )
+        revision = result.scalar_one_or_none()
+        if revision is None:
+            raise ResourceNotFoundError("Revision", revision_id)
+
+        # Build feedback comments (only unresolved ones are actionable)
+        feedback_comments = [
+            FeedbackComment(
+                file_path=comment.file_path,
+                line_number=comment.line_number,
+                anchor=comment.anchor,
+                body=comment.body,
+                line_content=comment.line_content,
+            )
+            for comment in revision.comments
+            if not comment.resolved
+        ]
+
+        # Get review summary
+        summary_text = ""
+        decision_text = "pending"
+        if revision.review_summary:
+            summary_text = revision.review_summary.body
+            decision_text = revision.review_summary.decision
+
+        return FeedbackBundle(
+            ticket_id=revision.ticket_id,
+            revision_id=revision_id,
+            revision_number=revision.number,
+            decision=decision_text,
+            summary=summary_text,
+            comments=feedback_comments,
+        )