xai-review 0.25.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

ai_review/clients/bitbucket/client.py

@@ -0,0 +1,31 @@
+from ai_review.clients.bitbucket.pr.client import BitbucketPullRequestsHTTPClient
+from httpx import AsyncClient, AsyncHTTPTransport
+
+from ai_review.config import settings
+from ai_review.libs.http.event_hooks.logger import LoggerEventHook
+from ai_review.libs.http.transports.retry import RetryTransport
+from ai_review.libs.logger import get_logger
+
+
+class BitbucketHTTPClient:
+    def __init__(self, client: AsyncClient):
+        self.pr = BitbucketPullRequestsHTTPClient(client)
+
+
+def get_bitbucket_http_client() -> BitbucketHTTPClient:
+    logger = get_logger("BITBUCKET_HTTP_CLIENT")
+    logger_event_hook = LoggerEventHook(logger=logger)
+    retry_transport = RetryTransport(logger=logger, transport=AsyncHTTPTransport())
+
+    client = AsyncClient(
+        timeout=settings.llm.http_client.timeout,
+        headers={"Authorization": f"Bearer {settings.vcs.http_client.api_token_value}"},
+        base_url=settings.vcs.http_client.api_url_value,
+        transport=retry_transport,
+        event_hooks={
+            "request": [logger_event_hook.request],
+            "response": [logger_event_hook.response],
+        }
+    )
+
+    return BitbucketHTTPClient(client=client)

ai_review/clients/bitbucket/pr/client.py

@@ -0,0 +1,104 @@
+from httpx import Response, QueryParams
+
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketGetPRCommentsQuerySchema,
+    BitbucketGetPRCommentsResponseSchema,
+    BitbucketCreatePRCommentRequestSchema,
+    BitbucketCreatePRCommentResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.files import (
+    BitbucketGetPRFilesQuerySchema,
+    BitbucketGetPRFilesResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.pull_request import BitbucketGetPRResponseSchema
+from ai_review.clients.bitbucket.pr.types import BitbucketPullRequestsHTTPClientProtocol
+from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.handlers import handle_http_error, HTTPClientError
+
+
+class BitbucketPullRequestsHTTPClientError(HTTPClientError):
+    pass
+
+
+class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClientProtocol):
+    @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
+    async def get_pull_request_api(self, workspace: str, repo_slug: str, pull_request_id: str) -> Response:
+        return await self.get(f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}")
+
+    @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
+    async def get_diffstat_api(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            query: BitbucketGetPRFilesQuerySchema,
+    ) -> Response:
+        return await self.get(
+            f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}/diffstat",
+            query=QueryParams(**query.model_dump()),
+        )
+
+    @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
+    async def get_comments_api(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            query: BitbucketGetPRCommentsQuerySchema,
+    ) -> Response:
+        return await self.get(
+            f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}/comments",
+            query=QueryParams(**query.model_dump()),
+        )
+
+    @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
+    async def create_comment_api(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            request: BitbucketCreatePRCommentRequestSchema,
+    ) -> Response:
+        return await self.post(
+            f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}/comments",
+            json=request.model_dump(by_alias=True),
+        )
+
+    async def get_pull_request(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRResponseSchema:
+        resp = await self.get_pull_request_api(workspace, repo_slug, pull_request_id)
+        return BitbucketGetPRResponseSchema.model_validate_json(resp.text)
+
+    async def get_files(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRFilesResponseSchema:
+        query = BitbucketGetPRFilesQuerySchema(pagelen=100)
+        resp = await self.get_diffstat_api(workspace, repo_slug, pull_request_id, query)
+        return BitbucketGetPRFilesResponseSchema.model_validate_json(resp.text)
+
+    async def get_comments(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRCommentsResponseSchema:
+        query = BitbucketGetPRCommentsQuerySchema(pagelen=100)
+        response = await self.get_comments_api(workspace, repo_slug, pull_request_id, query)
+        return BitbucketGetPRCommentsResponseSchema.model_validate_json(response.text)
+
+    async def create_comment(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            request: BitbucketCreatePRCommentRequestSchema
+    ) -> BitbucketCreatePRCommentResponseSchema:
+        response = await self.create_comment_api(workspace, repo_slug, pull_request_id, request)
+        return BitbucketCreatePRCommentResponseSchema.model_validate_json(response.text)

ai_review/clients/bitbucket/pr/schema/comments.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class BitbucketCommentContentSchema(BaseModel):
+    raw: str
+    html: str | None = None
+    markup: str | None = None
+
+
+class BitbucketCommentInlineSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    path: str
+    to_line: int | None = Field(alias="to", default=None)
+    from_line: int | None = Field(alias="from", default=None)
+
+
+class BitbucketPRCommentSchema(BaseModel):
+    id: int
+    inline: BitbucketCommentInlineSchema | None = None
+    content: BitbucketCommentContentSchema
+
+
+class BitbucketGetPRCommentsQuerySchema(BaseModel):
+    pagelen: int = 100
+
+
+class BitbucketGetPRCommentsResponseSchema(BaseModel):
+    size: int
+    page: int | None = None
+    next: str | None = None
+    values: list[BitbucketPRCommentSchema]
+    pagelen: int
+
+
+class BitbucketCreatePRCommentRequestSchema(BaseModel):
+    inline: BitbucketCommentInlineSchema | None = None
+    content: BitbucketCommentContentSchema
+
+
+class BitbucketCreatePRCommentResponseSchema(BaseModel):
+    id: int
+    inline: BitbucketCommentInlineSchema | None = None
+    content: BitbucketCommentContentSchema

ai_review/clients/bitbucket/pr/schema/files.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+
+
+class BitbucketPRFilePathSchema(BaseModel):
+    path: str
+
+
+class BitbucketPRFileSchema(BaseModel):
+    new: BitbucketPRFilePathSchema | None = None
+    old: BitbucketPRFilePathSchema | None = None
+    status: str
+    lines_added: int
+    lines_removed: int
+
+
+class BitbucketGetPRFilesQuerySchema(BaseModel):
+    pagelen: int = 100
+
+
+class BitbucketGetPRFilesResponseSchema(BaseModel):
+    size: int
+    page: int | None = None
+    next: str | None = None
+    values: list[BitbucketPRFileSchema]
+    pagelen: int

ai_review/clients/bitbucket/pr/schema/pull_request.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel, Field
+
+
+class BitbucketUserSchema(BaseModel):
+    uuid: str
+    nickname: str
+    display_name: str
+
+
+class BitbucketBranchSchema(BaseModel):
+    name: str
+
+
+class BitbucketCommitSchema(BaseModel):
+    hash: str
+
+
+class BitbucketRepositorySchema(BaseModel):
+    uuid: str
+    full_name: str
+
+
+class BitbucketPRLocationSchema(BaseModel):
+    branch: BitbucketBranchSchema
+    commit: BitbucketCommitSchema
+    repository: BitbucketRepositorySchema
+
+
+class BitbucketGetPRResponseSchema(BaseModel):
+    id: int
+    title: str
+    description: str | None = None
+    state: str
+    author: BitbucketUserSchema
+    source: BitbucketPRLocationSchema
+    destination: BitbucketPRLocationSchema
+    reviewers: list[BitbucketUserSchema] = Field(default_factory=list)
+    participants: list[BitbucketUserSchema] = Field(default_factory=list)

ai_review/clients/bitbucket/pr/types.py

@@ -0,0 +1,44 @@
+from typing import Protocol
+
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketGetPRCommentsResponseSchema,
+    BitbucketCreatePRCommentRequestSchema,
+    BitbucketCreatePRCommentResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.files import BitbucketGetPRFilesResponseSchema
+from ai_review.clients.bitbucket.pr.schema.pull_request import BitbucketGetPRResponseSchema
+
+
+class BitbucketPullRequestsHTTPClientProtocol(Protocol):
+    async def get_pull_request(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRResponseSchema:
+        ...
+
+    async def get_files(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRFilesResponseSchema:
+        ...
+
+    async def get_comments(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRCommentsResponseSchema:
+        ...
+
+    async def create_comment(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            request: BitbucketCreatePRCommentRequestSchema,
+    ) -> BitbucketCreatePRCommentResponseSchema:
+        ...

ai_review/libs/config/vcs/base.py

@@ -2,6 +2,7 @@ from typing import Annotated, Literal
 
 from pydantic import BaseModel, Field
 
+from ai_review.libs.config.vcs.bitbucket import BitbucketPipelineConfig, BitbucketHTTPClientConfig
 from ai_review.libs.config.vcs.github import GitHubPipelineConfig, GitHubHTTPClientConfig
 from ai_review.libs.config.vcs.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
 from ai_review.libs.constants.vcs_provider import VCSProvider
@@ -23,4 +24,13 @@ class GitHubVCSConfig(VCSConfigBase):
     http_client: GitHubHTTPClientConfig
 
 
-VCSConfig = Annotated[GitLabVCSConfig | GitHubVCSConfig, Field(discriminator="provider")]
+class BitbucketVCSConfig(VCSConfigBase):
+    provider: Literal[VCSProvider.BITBUCKET]
+    pipeline: BitbucketPipelineConfig
+    http_client: BitbucketHTTPClientConfig
+
+
+VCSConfig = Annotated[
+    GitLabVCSConfig | GitHubVCSConfig | BitbucketVCSConfig,
+    Field(discriminator="provider")
+]

ai_review/libs/config/vcs/bitbucket.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+from ai_review.libs.config.http import HTTPClientWithTokenConfig
+
+
+class BitbucketPipelineConfig(BaseModel):
+    workspace: str
+    repo_slug: str
+    pull_request_id: str
+
+
+class BitbucketHTTPClientConfig(HTTPClientWithTokenConfig):
+    pass

ai_review/libs/constants/vcs_provider.py

@@ -4,3 +4,4 @@ from enum import StrEnum
 class VCSProvider(StrEnum):
     GITHUB = "GITHUB"
     GITLAB = "GITLAB"
+    BITBUCKET = "BITBUCKET"

ai_review/services/vcs/bitbucket/client.py

@@ -0,0 +1,185 @@
+from ai_review.clients.bitbucket.client import get_bitbucket_http_client
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketCommentInlineSchema,
+    BitbucketCommentContentSchema,
+    BitbucketCreatePRCommentRequestSchema,
+)
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.types import (
+    VCSClientProtocol,
+    UserSchema,
+    BranchRefSchema,
+    ReviewInfoSchema,
+    ReviewCommentSchema,
+)
+
+logger = get_logger("BITBUCKET_VCS_CLIENT")
+
+
+class BitbucketVCSClient(VCSClientProtocol):
+    def __init__(self):
+        self.http_client = get_bitbucket_http_client()
+        self.workspace = settings.vcs.pipeline.workspace
+        self.repo_slug = settings.vcs.pipeline.repo_slug
+        self.pull_request_id = settings.vcs.pipeline.pull_request_id
+
+    async def get_review_info(self) -> ReviewInfoSchema:
+        try:
+            pr = await self.http_client.pr.get_pull_request(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            files = await self.http_client.pr.get_files(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+
+            logger.info(f"Fetched PR info for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+
+            return ReviewInfoSchema(
+                id=pr.id,
+                title=pr.title,
+                description=pr.description or "",
+                author=UserSchema(
+                    id=pr.author.uuid,
+                    name=pr.author.display_name,
+                    username=pr.author.nickname,
+                ),
+                labels=[],
+                base_sha=pr.destination.commit.hash,
+                head_sha=pr.source.commit.hash,
+                assignees=[
+                    UserSchema(
+                        id=user.uuid,
+                        name=user.display_name,
+                        username=user.nickname,
+                    )
+                    for user in pr.participants
+                ],
+                reviewers=[
+                    UserSchema(
+                        id=user.uuid,
+                        name=user.display_name,
+                        username=user.nickname,
+                    )
+                    for user in pr.reviewers
+                ],
+                source_branch=BranchRefSchema(
+                    ref=pr.source.branch.name,
+                    sha=pr.source.commit.hash,
+                ),
+                target_branch=BranchRefSchema(
+                    ref=pr.destination.branch.name,
+                    sha=pr.destination.commit.hash,
+                ),
+                changed_files=[
+                    file.new.path if file.new else file.old.path
+                    for file in files.values
+                ],
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch PR info {self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            return ReviewInfoSchema()
+
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_comments(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            logger.info(f"Fetched general comments for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+
+            return [
+                ReviewCommentSchema(id=comment.id, body=comment.content.raw)
+                for comment in response.values
+                if comment.inline is None
+            ]
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch general comments for "
+                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            return []
+
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_comments(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            logger.info(f"Fetched inline comments for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+
+            return [
+                ReviewCommentSchema(
+                    id=comment.id,
+                    body=comment.content.raw,
+                    file=comment.inline.path,
+                    line=comment.inline.to_line,
+                )
+                for comment in response.values
+                if comment.inline is not None
+            ]
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch inline comments for "
+                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            return []
+
+    async def create_general_comment(self, message: str) -> None:
+        try:
+            logger.info(
+                f"Posting general comment to PR {self.workspace}/{self.repo_slug}#{self.pull_request_id}: {message}"
+            )
+            request = BitbucketCreatePRCommentRequestSchema(
+                content=BitbucketCommentContentSchema(raw=message)
+            )
+            await self.http_client.pr.create_comment(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+            logger.info(
+                f"Created general comment in PR {self.workspace}/{self.repo_slug}#{self.pull_request_id}"
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to create general comment in PR "
+                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            raise
+
+    async def create_inline_comment(self, file: str, line: int, message: str) -> None:
+        try:
+            logger.info(
+                f"Posting inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
+                f"at {file}:{line}: {message}"
+            )
+            request = BitbucketCreatePRCommentRequestSchema(
+                content=BitbucketCommentContentSchema(raw=message),
+                inline=BitbucketCommentInlineSchema(path=file, to_line=line),
+            )
+            await self.http_client.pr.create_comment(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+            logger.info(
+                f"Created inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
+                f"at {file}:{line}"
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
+                f"at {file}:{line}: {error}"
+            )
+            raise

ai_review/services/vcs/factory.py

@@ -1,5 +1,6 @@
 from ai_review.config import settings
 from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
 from ai_review.services.vcs.github.client import GitHubVCSClient
 from ai_review.services.vcs.gitlab.client import GitLabVCSClient
 from ai_review.services.vcs.types import VCSClientProtocol
@@ -11,5 +12,7 @@ def get_vcs_client() -> VCSClientProtocol:
             return GitLabVCSClient()
         case VCSProvider.GITHUB:
             return GitHubVCSClient()
+        case VCSProvider.BITBUCKET:
+            return BitbucketVCSClient()
         case _:
             raise ValueError(f"Unsupported VCS provider: {settings.vcs.provider}")

ai_review/tests/fixtures/clients/bitbucket.py

@@ -0,0 +1,204 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketPRCommentSchema,
+    BitbucketCommentContentSchema,
+    BitbucketCommentInlineSchema,
+    BitbucketGetPRCommentsResponseSchema,
+    BitbucketCreatePRCommentRequestSchema,
+    BitbucketCreatePRCommentResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.files import (
+    BitbucketGetPRFilesResponseSchema,
+    BitbucketPRFileSchema,
+    BitbucketPRFilePathSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.pull_request import (
+    BitbucketUserSchema,
+    BitbucketBranchSchema,
+    BitbucketCommitSchema,
+    BitbucketRepositorySchema,
+    BitbucketPRLocationSchema,
+    BitbucketGetPRResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.types import BitbucketPullRequestsHTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.vcs.base import BitbucketVCSConfig
+from ai_review.libs.config.vcs.bitbucket import BitbucketPipelineConfig, BitbucketHTTPClientConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
+
+
+class FakeBitbucketPullRequestsHTTPClient(BitbucketPullRequestsHTTPClientProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    async def get_pull_request(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRResponseSchema:
+        self.calls.append(
+            (
+                "get_pull_request",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRResponseSchema(
+            id=1,
+            title="Fake Bitbucket PR",
+            description="This is a fake PR for testing",
+            state="OPEN",
+            author=BitbucketUserSchema(uuid="u1", display_name="Tester", nickname="tester"),
+            source=BitbucketPRLocationSchema(
+                commit=BitbucketCommitSchema(hash="def456"),
+                branch=BitbucketBranchSchema(name="feature/test"),
+                repository=BitbucketRepositorySchema(uuid="r1", full_name="workspace/repo"),
+            ),
+            destination=BitbucketPRLocationSchema(
+                commit=BitbucketCommitSchema(hash="abc123"),
+                branch=BitbucketBranchSchema(name="main"),
+                repository=BitbucketRepositorySchema(uuid="r1", full_name="workspace/repo"),
+            ),
+            reviewers=[BitbucketUserSchema(uuid="u2", display_name="Reviewer", nickname="reviewer")],
+            participants=[BitbucketUserSchema(uuid="u3", display_name="Participant", nickname="participant")],
+        )
+
+    async def get_files(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRFilesResponseSchema:
+        self.calls.append(
+            (
+                "get_files",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRFilesResponseSchema(
+            size=2,
+            page=1,
+            pagelen=100,
+            next=None,
+            values=[
+                BitbucketPRFileSchema(
+                    new=BitbucketPRFilePathSchema(path="app/main.py"),
+                    old=None,
+                    status="modified",
+                    lines_added=10,
+                    lines_removed=2,
+                ),
+                BitbucketPRFileSchema(
+                    new=BitbucketPRFilePathSchema(path="utils/helper.py"),
+                    old=None,
+                    status="added",
+                    lines_added=5,
+                    lines_removed=0,
+                ),
+            ],
+        )
+
+    async def get_comments(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRCommentsResponseSchema:
+        self.calls.append(
+            (
+                "get_comments",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRCommentsResponseSchema(
+            size=2,
+            page=1,
+            next=None,
+            values=[
+                BitbucketPRCommentSchema(
+                    id=1,
+                    inline=None,
+                    content=BitbucketCommentContentSchema(raw="General comment"),
+                ),
+                BitbucketPRCommentSchema(
+                    id=2,
+                    inline=BitbucketCommentInlineSchema(path="file.py", to_line=5),
+                    content=BitbucketCommentContentSchema(raw="Inline comment"),
+                ),
+            ],
+            pagelen=100,
+        )
+
+    async def create_comment(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            request: BitbucketCreatePRCommentRequestSchema
+    ) -> BitbucketCreatePRCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_comment",
+                {
+                    "workspace": workspace,
+                    "repo_slug": repo_slug,
+                    "pull_request_id": pull_request_id,
+                    **request.model_dump(by_alias=True)
+                }
+            )
+        )
+        return BitbucketCreatePRCommentResponseSchema(
+            id=10,
+            content=request.content,
+            inline=request.inline,
+        )
+
+
+class FakeBitbucketHTTPClient:
+    def __init__(self, pull_requests_client: BitbucketPullRequestsHTTPClientProtocol):
+        self.pr = pull_requests_client
+
+
+@pytest.fixture
+def fake_bitbucket_pull_requests_http_client() -> FakeBitbucketPullRequestsHTTPClient:
+    return FakeBitbucketPullRequestsHTTPClient()
+
+
+@pytest.fixture
+def fake_bitbucket_http_client(
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient
+) -> FakeBitbucketHTTPClient:
+    return FakeBitbucketHTTPClient(pull_requests_client=fake_bitbucket_pull_requests_http_client)
+
+
+@pytest.fixture
+def bitbucket_vcs_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_bitbucket_http_client: FakeBitbucketHTTPClient
+) -> BitbucketVCSClient:
+    monkeypatch.setattr(
+        "ai_review.services.vcs.bitbucket.client.get_bitbucket_http_client",
+        lambda: fake_bitbucket_http_client,
+    )
+    return BitbucketVCSClient()
+
+
+@pytest.fixture
+def bitbucket_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = BitbucketVCSConfig(
+        provider=VCSProvider.BITBUCKET,
+        pipeline=BitbucketPipelineConfig(
+            workspace="workspace",
+            repo_slug="repo",
+            pull_request_id="123",
+        ),
+        http_client=BitbucketHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://api.bitbucket.org/2.0"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "vcs", fake_config)

ai_review/tests/suites/services/vcs/bitbucket/test_service.py

@@ -0,0 +1,117 @@
+import pytest
+
+from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
+from ai_review.services.vcs.types import ReviewInfoSchema, ReviewCommentSchema
+from ai_review.tests.fixtures.clients.bitbucket import FakeBitbucketPullRequestsHTTPClient
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_get_review_info_returns_valid_schema(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should return detailed PR info with branches, author, reviewers, and files."""
+    info = await bitbucket_vcs_client.get_review_info()
+
+    assert isinstance(info, ReviewInfoSchema)
+    assert info.id == 1
+    assert info.title == "Fake Bitbucket PR"
+    assert info.description == "This is a fake PR for testing"
+
+    assert info.author.username == "tester"
+    assert {r.username for r in info.reviewers} == {"reviewer"}
+
+    assert info.source_branch.ref == "feature/test"
+    assert info.target_branch.ref == "main"
+    assert info.base_sha == "abc123"
+    assert info.head_sha == "def456"
+
+    assert "app/main.py" in info.changed_files
+    assert len(info.changed_files) == 2
+
+    called_methods = [name for name, _ in fake_bitbucket_pull_requests_http_client.calls]
+    assert called_methods == ["get_pull_request", "get_files"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_get_general_comments_filters_inline(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should return only general comments (without inline info)."""
+    comments = await bitbucket_vcs_client.get_general_comments()
+
+    assert all(isinstance(c, ReviewCommentSchema) for c in comments)
+    assert len(comments) == 1
+
+    first = comments[0]
+    assert first.body == "General comment"
+    assert first.file is None
+    assert first.line is None
+
+    called_methods = [name for name, _ in fake_bitbucket_pull_requests_http_client.calls]
+    assert called_methods == ["get_comments"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_get_inline_comments_filters_general(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should return only inline comments with file and line references."""
+    comments = await bitbucket_vcs_client.get_inline_comments()
+
+    assert all(isinstance(c, ReviewCommentSchema) for c in comments)
+    assert len(comments) == 1
+
+    first = comments[0]
+    assert first.body == "Inline comment"
+    assert first.file == "file.py"
+    assert first.line == 5
+
+    called_methods = [name for name, _ in fake_bitbucket_pull_requests_http_client.calls]
+    assert called_methods == ["get_comments"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_create_general_comment_posts_comment(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should post a general (non-inline) comment."""
+    message = "Hello from Bitbucket test!"
+
+    await bitbucket_vcs_client.create_general_comment(message)
+
+    calls = [args for name, args in fake_bitbucket_pull_requests_http_client.calls if name == "create_comment"]
+    assert len(calls) == 1
+    call_args = calls[0]
+    assert call_args["content"]["raw"] == message
+    assert call_args["workspace"] == "workspace"
+    assert call_args["repo_slug"] == "repo"
+
+
+@pytest.mark.asyncio
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+async def test_create_inline_comment_posts_comment(
+        bitbucket_vcs_client: BitbucketVCSClient,
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient,
+):
+    """Should post an inline comment with correct file and line."""
+    file = "file.py"
+    line = 10
+    message = "Looks good"
+
+    await bitbucket_vcs_client.create_inline_comment(file, line, message)
+
+    calls = [args for name, args in fake_bitbucket_pull_requests_http_client.calls if name == "create_comment"]
+    assert len(calls) == 1
+
+    call_args = calls[0]
+    assert call_args["content"]["raw"] == message
+    assert call_args["inline"]["path"] == file
+    assert call_args["inline"]["to"] == line

ai_review/tests/suites/services/vcs/test_factory.py

@@ -1,5 +1,6 @@
 import pytest
 
+from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
 from ai_review.services.vcs.factory import get_vcs_client
 from ai_review.services.vcs.github.client import GitHubVCSClient
 from ai_review.services.vcs.gitlab.client import GitLabVCSClient
@@ -17,7 +18,13 @@ def test_get_vcs_client_returns_gitlab(monkeypatch: pytest.MonkeyPatch):
     assert isinstance(client, GitLabVCSClient)
 
 
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+def test_get_vcs_client_returns_bitbucket(monkeypatch: pytest.MonkeyPatch):
+    client = get_vcs_client()
+    assert isinstance(client, BitbucketVCSClient)
+
+
 def test_get_vcs_client_unsupported_provider(monkeypatch: pytest.MonkeyPatch):
-    monkeypatch.setattr("ai_review.services.vcs.factory.settings.vcs.provider", "BITBUCKET")
+    monkeypatch.setattr("ai_review.services.vcs.factory.settings.vcs.provider", "UNSUPPORTED")
     with pytest.raises(ValueError):
         get_vcs_client()

{xai_review-0.25.0.dist-info → xai_review-0.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xai-review
-Version: 0.25.0
+Version: 0.26.0
 Summary: AI-powered code review tool
 Author-email: Nikita Filonov <nikita.filonov@example.com>
 Maintainer-email: Nikita Filonov <nikita.filonov@example.com>
@@ -67,7 +67,7 @@ improve code quality, enforce consistency, and speed up the review process.
 ✨ Key features:
 
 - **Multiple LLM providers** — choose between **OpenAI**, **Claude**, **Gemini**, or **Ollama**, and switch anytime.
-- **VCS integration** — works out of the box with GitLab, GitHub (more providers coming).
+- **VCS integration** — works out of the box with **GitLab**, **GitHub**, and **Bitbucket**.
 - **Customizable prompts** — adapt inline, context, and summary reviews to match your team’s coding guidelines.
 - **Flexible configuration** — supports `YAML`, `JSON`, and `ENV`, with seamless overrides in CI/CD pipelines.
 - **AI Review runs fully client-side** — it never proxies or inspects your requests.
@@ -170,7 +170,7 @@ Key things you can customize:
 
 - **LLM provider** — OpenAI, Gemini, Claude, or Ollama
 - **Model settings** — model name, temperature, max tokens
-- **VCS integration** — works out of the box with **GitLab** and **GitHub**.
+- **VCS integration** — works out of the box with **GitLab**, **GitHub**, and **Bitbucket**
 - **Review policy** — which files to include/exclude, review modes
 - **Prompts** — inline/context/summary prompt templates
 
@@ -209,7 +209,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: Nikita-Filonov/ai-review@v0.25.0
+      - uses: Nikita-Filonov/ai-review@v0.26.0
         with:
           review-command: ${{ inputs.review-command }}
         env:

{xai_review-0.25.0.dist-info → xai_review-0.26.0.dist-info}/RECORD

@@ -8,6 +8,15 @@ ai_review/cli/commands/run_inline_review.py,sha256=u55K-Su0PR2-NcK7XI2rTCIi7HTEi
 ai_review/cli/commands/run_review.py,sha256=i39IYNDE_lAiQQnKLmxG71Ao8WAIOSn82L9EpdbPcsI,261
 ai_review/cli/commands/run_summary_review.py,sha256=NqjepGH5cbqczPzcuMEAxO4dI58FEUZl0b6uRVQ9SiA,224
 ai_review/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_review/clients/bitbucket/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_review/clients/bitbucket/client.py,sha256=VaqaQ5USMPTOEeS5XPdr-RkMKsxUpJ2SBE6lcemkz-g,1174
+ai_review/clients/bitbucket/pr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_review/clients/bitbucket/pr/client.py,sha256=9C6vXBz8o0Df76N9WW4hORN-Q39Vd8I575AaidyW_HM,4359
+ai_review/clients/bitbucket/pr/types.py,sha256=ZICV4ghYChj1Jl9Nlwyw1_kwmGybX51GhGdGzkRaLCk,1296
+ai_review/clients/bitbucket/pr/schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_review/clients/bitbucket/pr/schema/comments.py,sha256=DLi3LhThXfHB9MJ5Akv7Yf_n-VttjvJAausSMoksHTY,1152
+ai_review/clients/bitbucket/pr/schema/files.py,sha256=A-h9Cgi0iJ6e9pGr5TcbpgSb3y9SMTqNi5FxJ7ySxpk,546
+ai_review/clients/bitbucket/pr/schema/pull_request.py,sha256=buGULgaCkxCUFSdiw0XTwaSIYP_p1rAEuKXUyJ_Mzi8,863
 ai_review/clients/claude/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_review/clients/claude/client.py,sha256=uEadbBNBJnzjHDczbxXiiw1V1H1PdUWKu-Gn-eIDEmw,1890
 ai_review/clients/claude/schema.py,sha256=LE6KCjJKDXqBGU2Cno5XL5R8vUfScgskE9MqvE0Pt2A,887
@@ -65,12 +74,13 @@ ai_review/libs/config/llm/meta.py,sha256=cEcAHOwy-mQBKo9_KJrQe0I7qppq6h99lSmoWX4
 ai_review/libs/config/llm/ollama.py,sha256=M6aiPb5GvYvkiGcgHTsh9bOw5JsBLqmfSKoIbHCejrU,372
 ai_review/libs/config/llm/openai.py,sha256=jGVL4gJ2wIacoKeK9Zc9LCgY95TxdeYOThdglVPErFU,262
 ai_review/libs/config/vcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ai_review/libs/config/vcs/base.py,sha256=zkfqBnI9kF_wbU9Nan19CKciKwOpWvdcZEt57jHujbE,786
+ai_review/libs/config/vcs/base.py,sha256=ks9lrSalkPUuG8ijlaw-8d-F-dv59GdSywHS2TsIKjs,1085
+ai_review/libs/config/vcs/bitbucket.py,sha256=on5sQaE57kM_zSmqdDUNrttVtTPGOzqLHM5s7eFN7DA,275
 ai_review/libs/config/vcs/github.py,sha256=hk-kuDLd8wecqtEb8PSqF7Yy_pkihplJhi6nB6FZID4,256
 ai_review/libs/config/vcs/gitlab.py,sha256=ecYfU158VgVlM6P5mgZn8FOqk3Xt60xx7gUqT5e22a4,252
 ai_review/libs/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_review/libs/constants/llm_provider.py,sha256=k7GzctIZ-TDsRlhTPbpGYgym_CO2YKVFp_oXG9dTBW0,143
-ai_review/libs/constants/vcs_provider.py,sha256=mZMC8DWIDWQ1YeUZh1a1jduX5enOAe1rWeza0RBmpTY,99
+ai_review/libs/constants/vcs_provider.py,sha256=xJpRdJIdAf05iH2x2f362d1MuviOlPVP7In-JvDVotE,127
 ai_review/libs/diff/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_review/libs/diff/models.py,sha256=RT4YJboOPA-AjNJGRj_HIZaJLEmROOhOgMh1wIGpIwY,2344
 ai_review/libs/diff/parser.py,sha256=2BGxZnRN3SRjNnZK4qIOW28aM93Ij__1SltwclJrlno,3817
@@ -150,8 +160,10 @@ ai_review/services/review/summary/schema.py,sha256=GipVNWrEKtgZPkytNSrXwzvX9Zq8P
 ai_review/services/review/summary/service.py,sha256=F4diIESc0y7YSiUKbInHWiSOW5tW_eQ0rpf78wKxLAo,562
 ai_review/services/review/summary/types.py,sha256=iDsucvx9xJZ5Xb5FN70da3bub3YDtt4vpQeVEK532E8,235
 ai_review/services/vcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ai_review/services/vcs/factory.py,sha256=yoZ5qCI_vq2bG-9lbunf70ojcxdoj8ms-4vY4c5BcJE,606
+ai_review/services/vcs/factory.py,sha256=AfhpZjQ257BkLjb_7zUyw_EUnfEiCUHgTph7GGm-MY4,753
 ai_review/services/vcs/types.py,sha256=S49LhAGHVAd_0QwZUr4JMhfc6DR-HikHR6-T_ETlTus,1998
+ai_review/services/vcs/bitbucket/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_review/services/vcs/bitbucket/client.py,sha256=OceM48MBoiUVKGTh8ZrrpVt8a1fDczCvOMD9VlwoapY,7253
 ai_review/services/vcs/github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_review/services/vcs/github/client.py,sha256=v6NV97xi_rtRQQi8atRdSrXKhSOQ7CeRHK7YjoyjU6Q,6353
 ai_review/services/vcs/gitlab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -159,6 +171,7 @@ ai_review/services/vcs/gitlab/client.py,sha256=LK95m-uFSxhDEVU-cBGct61NTKjul-ieL
 ai_review/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_review/tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_review/tests/fixtures/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_review/tests/fixtures/clients/bitbucket.py,sha256=XJK1nU7Wir5PnmwCUJ_2uTlByA5a_CTEuXc2a-WmWio,7122
 ai_review/tests/fixtures/clients/claude.py,sha256=6ldJlSSea0zsZV0hRDMi9mqWm0hWT3mp_ROwG_sVU1c,2203
 ai_review/tests/fixtures/clients/gemini.py,sha256=zhLJhm49keKEBCPOf_pLu8_zCatsKKAWM4-gXOhaXeM,2429
 ai_review/tests/fixtures/clients/github.py,sha256=Mzr8LcvVlYLhimzDMG4tEOQwj_6E6kTvYvSrq04R3YI,6865
@@ -242,14 +255,16 @@ ai_review/tests/suites/services/review/summary/__init__.py,sha256=47DEQpj8HBSa-_
 ai_review/tests/suites/services/review/summary/test_schema.py,sha256=HUbSDbQzBp-iTsGLs7hJfu-sz6sq9xLO0woGmZPWyx0,735
 ai_review/tests/suites/services/review/summary/test_service.py,sha256=ibiYOWQMZuQKRutIT_EKGq7DEPQvp62YhscNHeSWFVQ,588
 ai_review/tests/suites/services/vcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ai_review/tests/suites/services/vcs/test_factory.py,sha256=RLxKRSISJQGH9_h2QY7zLvMyAVF4shYoEmKrrmUySME,850
+ai_review/tests/suites/services/vcs/test_factory.py,sha256=EergKSHW4b7RZg9vJJ5Cj0XfPsDTLEclV1kq2_9greA,1138
+ai_review/tests/suites/services/vcs/bitbucket/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_review/tests/suites/services/vcs/bitbucket/test_service.py,sha256=JnG5BYTgGMb-doNjis2BOeI8JrMmvqwv82UFD5f92kg,4448
 ai_review/tests/suites/services/vcs/github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_review/tests/suites/services/vcs/github/test_service.py,sha256=c2sjecm4qzqYXuO9j6j35NQyJzqDpnXIJImRTcpkyHo,4378
 ai_review/tests/suites/services/vcs/gitlab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_review/tests/suites/services/vcs/gitlab/test_service.py,sha256=0dqgL5whzjcP-AQ4adP_12QfkYm_ZtdtMotmYm8Se7Y,4449
-xai_review-0.25.0.dist-info/licenses/LICENSE,sha256=p-v8m7Kmz4KKc7PcvsGiGEmCw9AiSXY4_ylOPy_u--Y,11343
-xai_review-0.25.0.dist-info/METADATA,sha256=-Ogp0iZijYiluzi9D_yO21Ur9N9Z4qJclmSeHrddU3A,11132
-xai_review-0.25.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xai_review-0.25.0.dist-info/entry_points.txt,sha256=JyC5URanMi5io5P_PXQf7H_I1OGIpk5cZQhaPQ0g4Zs,53
-xai_review-0.25.0.dist-info/top_level.txt,sha256=sTsZbfzLoqvRZKdKa-BcxWvjlHdrpbeJ6DrGY0EuR0E,10
-xai_review-0.25.0.dist-info/RECORD,,
+xai_review-0.26.0.dist-info/licenses/LICENSE,sha256=p-v8m7Kmz4KKc7PcvsGiGEmCw9AiSXY4_ylOPy_u--Y,11343
+xai_review-0.26.0.dist-info/METADATA,sha256=RXLUNKPnkpxjCcXWbKwFI8RN0UHvVjfWwtqGpVsukIs,11150
+xai_review-0.26.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xai_review-0.26.0.dist-info/entry_points.txt,sha256=JyC5URanMi5io5P_PXQf7H_I1OGIpk5cZQhaPQ0g4Zs,53
+xai_review-0.26.0.dist-info/top_level.txt,sha256=sTsZbfzLoqvRZKdKa-BcxWvjlHdrpbeJ6DrGY0EuR0E,10
+xai_review-0.26.0.dist-info/RECORD,,