xai-review 0.36.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

ai_review/clients/{bitbucket → bitbucket_cloud}/client.py

@@ -1,24 +1,25 @@
-from ai_review.clients.bitbucket.pr.client import BitbucketPullRequestsHTTPClient
 from httpx import AsyncClient, AsyncHTTPTransport
 
+from ai_review.clients.bitbucket_cloud.pr.client import BitbucketCloudPullRequestsHTTPClient
 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:
+class BitbucketCloudHTTPClient:
     def __init__(self, client: AsyncClient):
-        self.pr = BitbucketPullRequestsHTTPClient(client)
+        self.pr = BitbucketCloudPullRequestsHTTPClient(client)
 
 
-def get_bitbucket_http_client() -> BitbucketHTTPClient:
-    logger = get_logger("BITBUCKET_HTTP_CLIENT")
+def get_bitbucket_cloud_http_client() -> BitbucketCloudHTTPClient:
+    logger = get_logger("BITBUCKET_CLOUD_HTTP_CLIENT")
     logger_event_hook = LoggerEventHook(logger=logger)
     retry_transport = RetryTransport(logger=logger, transport=AsyncHTTPTransport())
 
     client = AsyncClient(
-        timeout=settings.llm.http_client.timeout,
+        verify=settings.vcs.http_client.verify,
+        timeout=settings.vcs.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,
@@ -28,4 +29,4 @@ def get_bitbucket_http_client() -> BitbucketHTTPClient:
         }
     )
 
-    return BitbucketHTTPClient(client=client)
+    return BitbucketCloudHTTPClient(client=client)

ai_review/clients/{bitbucket → bitbucket_cloud}/pr/client.py

@@ -1,68 +1,80 @@
 from httpx import Response, QueryParams
 
-from ai_review.clients.bitbucket.pr.schema.comments import (
-    BitbucketPRCommentSchema,
-    BitbucketGetPRCommentsQuerySchema,
-    BitbucketGetPRCommentsResponseSchema,
-    BitbucketCreatePRCommentRequestSchema,
-    BitbucketCreatePRCommentResponseSchema,
+from ai_review.clients.bitbucket_cloud.pr.schema.comments import (
+    BitbucketCloudPRCommentSchema,
+    BitbucketCloudGetPRCommentsQuerySchema,
+    BitbucketCloudGetPRCommentsResponseSchema,
+    BitbucketCloudCreatePRCommentRequestSchema,
+    BitbucketCloudCreatePRCommentResponseSchema,
 )
-from ai_review.clients.bitbucket.pr.schema.files import (
-    BitbucketPRFileSchema,
-    BitbucketGetPRFilesQuerySchema,
-    BitbucketGetPRFilesResponseSchema,
+from ai_review.clients.bitbucket_cloud.pr.schema.files import (
+    BitbucketCloudPRFileSchema,
+    BitbucketCloudGetPRFilesQuerySchema,
+    BitbucketCloudGetPRFilesResponseSchema,
 )
-from ai_review.clients.bitbucket.pr.schema.pull_request import BitbucketGetPRResponseSchema
-from ai_review.clients.bitbucket.pr.types import BitbucketPullRequestsHTTPClientProtocol
-from ai_review.clients.bitbucket.tools import bitbucket_has_next_page
+from ai_review.clients.bitbucket_cloud.pr.schema.pull_request import BitbucketCloudGetPRResponseSchema
+from ai_review.clients.bitbucket_cloud.pr.types import BitbucketCloudPullRequestsHTTPClientProtocol
+from ai_review.clients.bitbucket_cloud.tools import bitbucket_cloud_has_next_page
 from ai_review.config import settings
 from ai_review.libs.http.client import HTTPClient
 from ai_review.libs.http.handlers import handle_http_error, HTTPClientError
 from ai_review.libs.http.paginate import paginate
 
 
-class BitbucketPullRequestsHTTPClientError(HTTPClientError):
+class BitbucketCloudPullRequestsHTTPClientError(HTTPClientError):
     pass
 
 
-class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClientProtocol):
-    @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
+class BitbucketCloudPullRequestsHTTPClient(HTTPClient, BitbucketCloudPullRequestsHTTPClientProtocol):
+    @handle_http_error(
+        client="BitbucketCloudPullRequestsHTTPClient",
+        exception=BitbucketCloudPullRequestsHTTPClientError
+    )
     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)
+    @handle_http_error(
+        client="BitbucketCloudPullRequestsHTTPClient",
+        exception=BitbucketCloudPullRequestsHTTPClientError
+    )
     async def get_diffstat_api(
             self,
             workspace: str,
             repo_slug: str,
             pull_request_id: str,
-            query: BitbucketGetPRFilesQuerySchema,
+            query: BitbucketCloudGetPRFilesQuerySchema,
     ) -> Response:
         return await self.get(
             f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}/diffstat",
             query=QueryParams(**query.model_dump(by_alias=True)),
         )
 
-    @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
+    @handle_http_error(
+        client="BitbucketCloudPullRequestsHTTPClient",
+        exception=BitbucketCloudPullRequestsHTTPClientError
+    )
     async def get_comments_api(
             self,
             workspace: str,
             repo_slug: str,
             pull_request_id: str,
-            query: BitbucketGetPRCommentsQuerySchema,
+            query: BitbucketCloudGetPRCommentsQuerySchema,
     ) -> Response:
         return await self.get(
             f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}/comments",
             query=QueryParams(**query.model_dump(by_alias=True)),
         )
 
-    @handle_http_error(client="BitbucketPullRequestsHTTPClient", exception=BitbucketPullRequestsHTTPClientError)
+    @handle_http_error(
+        client="BitbucketCloudPullRequestsHTTPClient",
+        exception=BitbucketCloudPullRequestsHTTPClientError
+    )
     async def create_comment_api(
             self,
             workspace: str,
             repo_slug: str,
             pull_request_id: str,
-            request: BitbucketCreatePRCommentRequestSchema,
+            request: BitbucketCloudCreatePRCommentRequestSchema,
     ) -> Response:
         return await self.post(
             f"/repositories/{workspace}/{repo_slug}/pullrequests/{pull_request_id}/comments",
@@ -74,31 +86,31 @@ class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClien
             workspace: str,
             repo_slug: str,
             pull_request_id: str
-    ) -> BitbucketGetPRResponseSchema:
+    ) -> BitbucketCloudGetPRResponseSchema:
         resp = await self.get_pull_request_api(workspace, repo_slug, pull_request_id)
-        return BitbucketGetPRResponseSchema.model_validate_json(resp.text)
+        return BitbucketCloudGetPRResponseSchema.model_validate_json(resp.text)
 
     async def get_files(
             self,
             workspace: str,
             repo_slug: str,
             pull_request_id: str
-    ) -> BitbucketGetPRFilesResponseSchema:
+    ) -> BitbucketCloudGetPRFilesResponseSchema:
         async def fetch_page(page: int) -> Response:
-            query = BitbucketGetPRFilesQuerySchema(page=page, page_len=settings.vcs.pagination.per_page)
+            query = BitbucketCloudGetPRFilesQuerySchema(page=page, page_len=settings.vcs.pagination.per_page)
             return await self.get_diffstat_api(workspace, repo_slug, pull_request_id, query)
 
-        def extract_items(response: Response) -> list[BitbucketPRFileSchema]:
-            result = BitbucketGetPRFilesResponseSchema.model_validate_json(response.text)
+        def extract_items(response: Response) -> list[BitbucketCloudPRFileSchema]:
+            result = BitbucketCloudGetPRFilesResponseSchema.model_validate_json(response.text)
             return result.values
 
         items = await paginate(
             max_pages=settings.vcs.pagination.max_pages,
             fetch_page=fetch_page,
             extract_items=extract_items,
-            has_next_page=bitbucket_has_next_page
+            has_next_page=bitbucket_cloud_has_next_page
         )
-        return BitbucketGetPRFilesResponseSchema(
+        return BitbucketCloudGetPRFilesResponseSchema(
             size=len(items),
             values=items,
             page_len=settings.vcs.pagination.per_page
@@ -109,22 +121,22 @@ class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClien
             workspace: str,
             repo_slug: str,
             pull_request_id: str
-    ) -> BitbucketGetPRCommentsResponseSchema:
+    ) -> BitbucketCloudGetPRCommentsResponseSchema:
         async def fetch_page(page: int) -> Response:
-            query = BitbucketGetPRCommentsQuerySchema(page=page, page_len=settings.vcs.pagination.per_page)
+            query = BitbucketCloudGetPRCommentsQuerySchema(page=page, page_len=settings.vcs.pagination.per_page)
             return await self.get_comments_api(workspace, repo_slug, pull_request_id, query)
 
-        def extract_items(response: Response) -> list[BitbucketPRCommentSchema]:
-            result = BitbucketGetPRCommentsResponseSchema.model_validate_json(response.text)
+        def extract_items(response: Response) -> list[BitbucketCloudPRCommentSchema]:
+            result = BitbucketCloudGetPRCommentsResponseSchema.model_validate_json(response.text)
             return result.values
 
         items = await paginate(
             max_pages=settings.vcs.pagination.max_pages,
             fetch_page=fetch_page,
             extract_items=extract_items,
-            has_next_page=bitbucket_has_next_page
+            has_next_page=bitbucket_cloud_has_next_page
         )
-        return BitbucketGetPRCommentsResponseSchema(
+        return BitbucketCloudGetPRCommentsResponseSchema(
             size=len(items),
             values=items,
             page_len=settings.vcs.pagination.per_page
@@ -135,7 +147,7 @@ class BitbucketPullRequestsHTTPClient(HTTPClient, BitbucketPullRequestsHTTPClien
             workspace: str,
             repo_slug: str,
             pull_request_id: str,
-            request: BitbucketCreatePRCommentRequestSchema
-    ) -> BitbucketCreatePRCommentResponseSchema:
+            request: BitbucketCloudCreatePRCommentRequestSchema
+    ) -> BitbucketCloudCreatePRCommentResponseSchema:
         response = await self.create_comment_api(workspace, repo_slug, pull_request_id, request)
-        return BitbucketCreatePRCommentResponseSchema.model_validate_json(response.text)
+        return BitbucketCloudCreatePRCommentResponseSchema.model_validate_json(response.text)

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

@@ -0,0 +1,59 @@
+from pydantic import BaseModel, Field, ConfigDict
+
+from ai_review.clients.bitbucket_cloud.pr.schema.user import BitbucketCloudUserSchema
+
+
+class BitbucketCloudCommentContentSchema(BaseModel):
+    raw: str
+    html: str | None = None
+    markup: str | None = None
+
+
+class BitbucketCloudCommentInlineSchema(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 BitbucketCloudCommentParentSchema(BaseModel):
+    id: int
+
+
+class BitbucketCloudPRCommentSchema(BaseModel):
+    id: int
+    user: BitbucketCloudUserSchema | None = None
+    parent: BitbucketCloudCommentParentSchema | None = None
+    inline: BitbucketCloudCommentInlineSchema | None = None
+    content: BitbucketCloudCommentContentSchema
+
+
+class BitbucketCloudGetPRCommentsQuerySchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    page: int = 1
+    page_len: int = Field(alias="pagelen", default=100)
+
+
+class BitbucketCloudGetPRCommentsResponseSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    size: int
+    page: int | None = None
+    next: str | None = None
+    values: list[BitbucketCloudPRCommentSchema]
+    page_len: int = Field(alias="pagelen")
+
+
+class BitbucketCloudCreatePRCommentRequestSchema(BaseModel):
+    parent: BitbucketCloudCommentParentSchema | None = None
+    inline: BitbucketCloudCommentInlineSchema | None = None
+    content: BitbucketCloudCommentContentSchema
+
+
+class BitbucketCloudCreatePRCommentResponseSchema(BaseModel):
+    id: int
+    parent: BitbucketCloudCommentParentSchema | None = None
+    inline: BitbucketCloudCommentInlineSchema | None = None
+    content: BitbucketCloudCommentContentSchema

ai_review/clients/{bitbucket → bitbucket_cloud}/pr/schema/files.py

@@ -1,30 +1,30 @@
 from pydantic import BaseModel, Field, ConfigDict
 
 
-class BitbucketPRFilePathSchema(BaseModel):
+class BitbucketCloudPRFilePathSchema(BaseModel):
     path: str
 
 
-class BitbucketPRFileSchema(BaseModel):
-    new: BitbucketPRFilePathSchema | None = None
-    old: BitbucketPRFilePathSchema | None = None
+class BitbucketCloudPRFileSchema(BaseModel):
+    new: BitbucketCloudPRFilePathSchema | None = None
+    old: BitbucketCloudPRFilePathSchema | None = None
     status: str
     lines_added: int
     lines_removed: int
 
 
-class BitbucketGetPRFilesQuerySchema(BaseModel):
+class BitbucketCloudGetPRFilesQuerySchema(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
     page: int = 1
     page_len: int = Field(alias="pagelen", default=100)
 
 
-class BitbucketGetPRFilesResponseSchema(BaseModel):
+class BitbucketCloudGetPRFilesResponseSchema(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
 
     size: int
     page: int | None = None
     next: str | None = None
-    values: list[BitbucketPRFileSchema]
+    values: list[BitbucketCloudPRFileSchema]
     page_len: int = Field(alias="pagelen")

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

@@ -0,0 +1,34 @@
+from pydantic import BaseModel, Field
+
+from ai_review.clients.bitbucket_cloud.pr.schema.user import BitbucketCloudUserSchema
+
+
+class BitbucketCloudBranchSchema(BaseModel):
+    name: str
+
+
+class BitbucketCloudCommitSchema(BaseModel):
+    hash: str
+
+
+class BitbucketCloudRepositorySchema(BaseModel):
+    uuid: str
+    full_name: str
+
+
+class BitbucketCloudPRLocationSchema(BaseModel):
+    branch: BitbucketCloudBranchSchema
+    commit: BitbucketCloudCommitSchema
+    repository: BitbucketCloudRepositorySchema
+
+
+class BitbucketCloudGetPRResponseSchema(BaseModel):
+    id: int
+    title: str
+    description: str | None = None
+    state: str
+    author: BitbucketCloudUserSchema
+    source: BitbucketCloudPRLocationSchema
+    destination: BitbucketCloudPRLocationSchema
+    reviewers: list[BitbucketCloudUserSchema] = Field(default_factory=list)
+    participants: list[BitbucketCloudUserSchema] = Field(default_factory=list)

ai_review/clients/{bitbucket → bitbucket_cloud}/pr/schema/user.py

@@ -1,7 +1,7 @@
 from pydantic import BaseModel
 
 
-class BitbucketUserSchema(BaseModel):
+class BitbucketCloudUserSchema(BaseModel):
     uuid: str
     nickname: str
     display_name: str

ai_review/clients/bitbucket_cloud/pr/types.py

@@ -0,0 +1,44 @@
+from typing import Protocol
+
+from ai_review.clients.bitbucket_cloud.pr.schema.comments import (
+    BitbucketCloudGetPRCommentsResponseSchema,
+    BitbucketCloudCreatePRCommentRequestSchema,
+    BitbucketCloudCreatePRCommentResponseSchema,
+)
+from ai_review.clients.bitbucket_cloud.pr.schema.files import BitbucketCloudGetPRFilesResponseSchema
+from ai_review.clients.bitbucket_cloud.pr.schema.pull_request import BitbucketCloudGetPRResponseSchema
+
+
+class BitbucketCloudPullRequestsHTTPClientProtocol(Protocol):
+    async def get_pull_request(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketCloudGetPRResponseSchema:
+        ...
+
+    async def get_files(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketCloudGetPRFilesResponseSchema:
+        ...
+
+    async def get_comments(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketCloudGetPRCommentsResponseSchema:
+        ...
+
+    async def create_comment(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            request: BitbucketCloudCreatePRCommentRequestSchema,
+    ) -> BitbucketCloudCreatePRCommentResponseSchema:
+        ...

ai_review/clients/{bitbucket → bitbucket_cloud}/tools.py

@@ -1,6 +1,6 @@
 from httpx import Response
 
 
-def bitbucket_has_next_page(response: Response) -> bool:
+def bitbucket_cloud_has_next_page(response: Response) -> bool:
     data = response.json()
     return bool(data.get("next"))

ai_review/clients/bitbucket_server/client.py

@@ -0,0 +1,32 @@
+from ai_review.clients.bitbucket_server.pr.client import BitbucketServerPullRequestsHTTPClient
+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 BitbucketServerHTTPClient:
+    def __init__(self, client: AsyncClient):
+        self.pr = BitbucketServerPullRequestsHTTPClient(client)
+
+
+def get_bitbucket_server_http_client() -> BitbucketServerHTTPClient:
+    logger = get_logger("BITBUCKET_SERVER_HTTP_CLIENT")
+    logger_event_hook = LoggerEventHook(logger=logger)
+    retry_transport = RetryTransport(logger=logger, transport=AsyncHTTPTransport())
+
+    client = AsyncClient(
+        verify=settings.vcs.http_client.verify,
+        timeout=settings.vcs.http_client.timeout,
+        headers={"Authorization": f"Basic {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 BitbucketServerHTTPClient(client=client)

ai_review/clients/bitbucket_server/pr/client.py

@@ -0,0 +1,163 @@
+from httpx import Response, QueryParams
+
+from ai_review.clients.bitbucket_server.pr.schema.changes import (
+    BitbucketServerChangeSchema,
+    BitbucketServerGetPRChangesQuerySchema,
+    BitbucketServerGetPRChangesResponseSchema,
+)
+from ai_review.clients.bitbucket_server.pr.schema.comments import (
+    BitbucketServerCommentSchema,
+    BitbucketServerGetPRCommentsQuerySchema,
+    BitbucketServerGetPRCommentsResponseSchema,
+    BitbucketServerCreatePRCommentRequestSchema,
+    BitbucketServerCreatePRCommentResponseSchema
+)
+from ai_review.clients.bitbucket_server.pr.schema.pull_request import BitbucketServerGetPRResponseSchema
+from ai_review.clients.bitbucket_server.pr.types import BitbucketServerPullRequestsHTTPClientProtocol
+from ai_review.clients.bitbucket_server.tools import bitbucket_server_has_next_page
+from ai_review.config import settings
+from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.handlers import handle_http_error, HTTPClientError
+from ai_review.libs.http.paginate import paginate
+
+
+class BitbucketServerPullRequestsHTTPClientError(HTTPClientError):
+    pass
+
+
+class BitbucketServerPullRequestsHTTPClient(HTTPClient, BitbucketServerPullRequestsHTTPClientProtocol):
+    @handle_http_error(
+        client="BitbucketServerPullRequestsHTTPClient",
+        exception=BitbucketServerPullRequestsHTTPClientError
+    )
+    async def get_pull_request_api(self, project_key: str, repo_slug: str, pull_request_id: int) -> Response:
+        return await self.get(f"/projects/{project_key}/repos/{repo_slug}/pull-requests/{pull_request_id}")
+
+    @handle_http_error(
+        client="BitbucketServerPullRequestsHTTPClient",
+        exception=BitbucketServerPullRequestsHTTPClientError
+    )
+    async def get_changes_api(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+            query: BitbucketServerGetPRChangesQuerySchema,
+    ) -> Response:
+        return await self.get(
+            f"/projects/{project_key}/repos/{repo_slug}/pull-requests/{pull_request_id}/changes",
+            query=QueryParams(**query.model_dump(by_alias=True)),
+        )
+
+    @handle_http_error(
+        client="BitbucketServerPullRequestsHTTPClient",
+        exception=BitbucketServerPullRequestsHTTPClientError
+    )
+    async def get_comments_api(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+            query: BitbucketServerGetPRCommentsQuerySchema,
+    ) -> Response:
+        return await self.get(
+            f"/projects/{project_key}/repos/{repo_slug}/pull-requests/{pull_request_id}/comments",
+            query=QueryParams(**query.model_dump(by_alias=True)),
+        )
+
+    @handle_http_error(
+        client="BitbucketServerPullRequestsHTTPClient",
+        exception=BitbucketServerPullRequestsHTTPClientError
+    )
+    async def create_comment_api(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+            request: BitbucketServerCreatePRCommentRequestSchema,
+    ) -> Response:
+        return await self.post(
+            f"/projects/{project_key}/repos/{repo_slug}/pull-requests/{pull_request_id}/comments",
+            json=request.model_dump(by_alias=True),
+        )
+
+    async def get_pull_request(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+    ) -> BitbucketServerGetPRResponseSchema:
+        resp = await self.get_pull_request_api(project_key, repo_slug, pull_request_id)
+        return BitbucketServerGetPRResponseSchema.model_validate_json(resp.text)
+
+    async def get_changes(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+    ) -> BitbucketServerGetPRChangesResponseSchema:
+        async def fetch_page(page: int) -> Response:
+            start = (page - 1) * settings.vcs.pagination.per_page
+            query = BitbucketServerGetPRChangesQuerySchema(start=start, limit=settings.vcs.pagination.per_page)
+            return await self.get_changes_api(project_key, repo_slug, pull_request_id, query)
+
+        def extract_items(response: Response) -> list[BitbucketServerChangeSchema]:
+            result = BitbucketServerGetPRChangesResponseSchema.model_validate_json(response.text)
+            return result.values
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=bitbucket_server_has_next_page,
+        )
+
+        return BitbucketServerGetPRChangesResponseSchema(
+            size=len(items),
+            start=0,
+            limit=settings.vcs.pagination.per_page,
+            values=items,
+            is_last_page=True,
+            next_page_start=None,
+        )
+
+    async def get_comments(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+    ) -> BitbucketServerGetPRCommentsResponseSchema:
+        async def fetch_page(page: int) -> Response:
+            start = (page - 1) * settings.vcs.pagination.per_page
+            query = BitbucketServerGetPRCommentsQuerySchema(start=start, limit=settings.vcs.pagination.per_page)
+            return await self.get_comments_api(project_key, repo_slug, pull_request_id, query)
+
+        def extract_items(response: Response) -> list[BitbucketServerCommentSchema]:
+            result = BitbucketServerGetPRCommentsResponseSchema.model_validate_json(response.text)
+            return result.values
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=bitbucket_server_has_next_page,
+        )
+
+        return BitbucketServerGetPRCommentsResponseSchema(
+            size=len(items),
+            start=0,
+            limit=settings.vcs.pagination.per_page,
+            values=items,
+            is_last_page=True,
+            next_page_start=None,
+        )
+
+    async def create_comment(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+            request: BitbucketServerCreatePRCommentRequestSchema
+    ) -> BitbucketServerCreatePRCommentResponseSchema:
+        response = await self.create_comment_api(project_key, repo_slug, pull_request_id, request)
+        return BitbucketServerCreatePRCommentResponseSchema.model_validate_json(response.text)

ai_review/clients/bitbucket_server/pr/schema/changes.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class BitbucketServerChangePathSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    to_string: str = Field(alias="toString")
+
+
+class BitbucketServerChangeSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    path: BitbucketServerChangePathSchema
+    type: str
+    src_path: BitbucketServerChangePathSchema | None = Field(default=None, alias="srcPath")
+    node_type: str = Field(alias="nodeType")
+    executable: bool | None = None
+    percent_unchanged: float | None = Field(default=None, alias="percentUnchanged")
+
+
+class BitbucketServerGetPRChangesQuerySchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    start: int = 0
+    limit: int = 100
+
+
+class BitbucketServerGetPRChangesResponseSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    size: int
+    limit: int
+    start: int
+    values: list[BitbucketServerChangeSchema]
+    is_last_page: bool = Field(alias="isLastPage")
+    next_page_start: int | None = Field(default=None, alias="nextPageStart")