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

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

@@ -0,0 +1,55 @@
+from pydantic import BaseModel, Field, ConfigDict
+
+from ai_review.clients.bitbucket_server.pr.schema.user import BitbucketServerUserSchema
+
+
+class BitbucketServerCommentParentSchema(BaseModel):
+    id: int
+
+
+class BitbucketServerCommentAnchorSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    path: str | None = None
+    line: int | None = None
+    line_type: str | None = Field(default=None, alias="lineType")
+
+
+class BitbucketServerCommentSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: int
+    text: str
+    author: BitbucketServerUserSchema
+    anchor: BitbucketServerCommentAnchorSchema | None = None
+    comments: list["BitbucketServerCommentSchema"] = Field(default_factory=list)
+    created_date: int = Field(alias="createdDate")
+    updated_date: int = Field(alias="updatedDate")
+
+
+class BitbucketServerGetPRCommentsQuerySchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    start: int = 0
+    limit: int = 100
+
+
+class BitbucketServerGetPRCommentsResponseSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    size: int
+    limit: int
+    start: int
+    values: list[BitbucketServerCommentSchema]
+    is_last_page: bool = Field(alias="isLastPage")
+    next_page_start: int | None = Field(default=None, alias="nextPageStart")
+
+
+class BitbucketServerCreatePRCommentRequestSchema(BaseModel):
+    text: str
+    parent: BitbucketServerCommentParentSchema | None = None
+    anchor: BitbucketServerCommentAnchorSchema | None = None
+
+
+class BitbucketServerCreatePRCommentResponseSchema(BitbucketServerCommentSchema):
+    pass

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

@@ -0,0 +1,48 @@
+from pydantic import BaseModel, Field, ConfigDict
+
+from ai_review.clients.bitbucket_server.pr.schema.user import BitbucketServerUserSchema
+
+
+class BitbucketServerProjectSchema(BaseModel):
+    key: str
+
+
+class BitbucketServerRepositorySchema(BaseModel):
+    slug: str
+    name: str
+    project: BitbucketServerProjectSchema
+
+
+class BitbucketServerRefSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    display_id: str = Field(alias="displayId")
+    latest_commit: str = Field(alias="latestCommit")
+    repository: BitbucketServerRepositorySchema
+
+
+class BitbucketServerParticipantSchema(BaseModel):
+    user: BitbucketServerUserSchema
+    role: str
+    approved: bool | None = None
+    status: str | None = None
+
+
+class BitbucketServerGetPRResponseSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: int
+    version: int | None = None
+    title: str
+    description: str | None = None
+    state: str
+    open: bool
+    locked: bool
+    author: BitbucketServerParticipantSchema
+    reviewers: list[BitbucketServerParticipantSchema] = Field(default_factory=list)
+    from_ref: BitbucketServerRefSchema = Field(alias="fromRef")
+    to_ref: BitbucketServerRefSchema = Field(alias="toRef")
+    created_date: int = Field(alias="createdDate")
+    updated_date: int = Field(alias="updatedDate")
+    links: dict | None = None

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

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class BitbucketServerUserSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: int | None = None
+    name: str
+    slug: str | None = None
+    type: str | None = None
+    active: bool | None = None
+    display_name: str = Field(alias="displayName")
+    email_address: str | None = Field(default=None, alias="emailAddress")

ai_review/clients/bitbucket_server/pr/types.py

@@ -0,0 +1,44 @@
+from typing import Protocol
+
+from ai_review.clients.bitbucket_server.pr.schema.changes import BitbucketServerGetPRChangesResponseSchema
+from ai_review.clients.bitbucket_server.pr.schema.comments import (
+    BitbucketServerGetPRCommentsResponseSchema,
+    BitbucketServerCreatePRCommentRequestSchema,
+    BitbucketServerCreatePRCommentResponseSchema
+)
+from ai_review.clients.bitbucket_server.pr.schema.pull_request import BitbucketServerGetPRResponseSchema
+
+
+class BitbucketServerPullRequestsHTTPClientProtocol(Protocol):
+    async def get_pull_request(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+    ) -> BitbucketServerGetPRResponseSchema:
+        ...
+
+    async def get_changes(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+    ) -> BitbucketServerGetPRChangesResponseSchema:
+        ...
+
+    async def get_comments(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+    ) -> BitbucketServerGetPRCommentsResponseSchema:
+        ...
+
+    async def create_comment(
+            self,
+            project_key: str,
+            repo_slug: str,
+            pull_request_id: int,
+            request: BitbucketServerCreatePRCommentRequestSchema,
+    ) -> BitbucketServerCreatePRCommentResponseSchema:
+        ...

ai_review/clients/bitbucket_server/tools.py

@@ -0,0 +1,6 @@
+from httpx import Response
+
+
+def bitbucket_server_has_next_page(response: Response) -> bool:
+    data = response.json()
+    return not data.get("isLastPage", True)

ai_review/libs/config/vcs/base.py

@@ -2,7 +2,14 @@ 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.bitbucket_cloud import (
+    BitbucketCloudPipelineConfig,
+    BitbucketCloudHTTPClientConfig
+)
+from ai_review.libs.config.vcs.bitbucket_server import (
+    BitbucketServerPipelineConfig,
+    BitbucketServerHTTPClientConfig
+)
 from ai_review.libs.config.vcs.gitea import GiteaPipelineConfig, GiteaHTTPClientConfig
 from ai_review.libs.config.vcs.github import GitHubPipelineConfig, GitHubHTTPClientConfig
 from ai_review.libs.config.vcs.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
@@ -33,13 +40,23 @@ class GitHubVCSConfig(VCSConfigBase):
     http_client: GitHubHTTPClientConfig
 
 
-class BitbucketVCSConfig(VCSConfigBase):
-    provider: Literal[VCSProvider.BITBUCKET]
-    pipeline: BitbucketPipelineConfig
-    http_client: BitbucketHTTPClientConfig
+class BitbucketCloudVCSConfig(VCSConfigBase):
+    provider: Literal[VCSProvider.BITBUCKET_CLOUD]
+    pipeline: BitbucketCloudPipelineConfig
+    http_client: BitbucketCloudHTTPClientConfig
+
+
+class BitbucketServerVCSConfig(VCSConfigBase):
+    provider: Literal[VCSProvider.BITBUCKET_SERVER]
+    pipeline: BitbucketServerPipelineConfig
+    http_client: BitbucketServerHTTPClientConfig
 
 
 VCSConfig = Annotated[
-    GiteaVCSConfig | GitLabVCSConfig | GitHubVCSConfig | BitbucketVCSConfig,
+    GiteaVCSConfig
+    | GitLabVCSConfig
+    | GitHubVCSConfig
+    | BitbucketCloudVCSConfig
+    | BitbucketServerVCSConfig,
     Field(discriminator="provider")
 ]

ai_review/libs/config/vcs/{bitbucket.py → bitbucket_cloud.py}

@@ -3,11 +3,11 @@ from pydantic import BaseModel
 from ai_review.libs.config.http import HTTPClientWithTokenConfig
 
 
-class BitbucketPipelineConfig(BaseModel):
+class BitbucketCloudPipelineConfig(BaseModel):
     workspace: str
     repo_slug: str
     pull_request_id: str
 
 
-class BitbucketHTTPClientConfig(HTTPClientWithTokenConfig):
+class BitbucketCloudHTTPClientConfig(HTTPClientWithTokenConfig):
     pass

ai_review/libs/config/vcs/bitbucket_server.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+from ai_review.libs.config.http import HTTPClientWithTokenConfig
+
+
+class BitbucketServerPipelineConfig(BaseModel):
+    project_key: str
+    repo_slug: str
+    pull_request_id: int
+
+
+class BitbucketServerHTTPClientConfig(HTTPClientWithTokenConfig):
+    pass

ai_review/libs/constants/vcs_provider.py

@@ -5,4 +5,5 @@ class VCSProvider(StrEnum):
     GITEA = "GITEA"
     GITHUB = "GITHUB"
     GITLAB = "GITLAB"
-    BITBUCKET = "BITBUCKET"
+    BITBUCKET_CLOUD = "BITBUCKET_CLOUD"
+    BITBUCKET_SERVER = "BITBUCKET_SERVER"

ai_review/libs/http/client.py

@@ -8,7 +8,7 @@ class HTTPClient:
         self.client = client
 
     async def get(self, url: str, query: QueryParams | None = None) -> Response:
-        return await self.client.get(url=url, params=query)
+        return await self.client.get(url=url, params=query, follow_redirects=True)
 
     async def post(self, url: str, json: Any | None = None) -> Response:
         return await self.client.post(url=url, json=json)

ai_review/services/vcs/{bitbucket → bitbucket_cloud}/adapter.py

@@ -1,8 +1,8 @@
-from ai_review.clients.bitbucket.pr.schema.comments import BitbucketPRCommentSchema
+from ai_review.clients.bitbucket_cloud.pr.schema.comments import BitbucketCloudPRCommentSchema
 from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
 
 
-def get_review_comment_from_bitbucket_pr_comment(comment: BitbucketPRCommentSchema) -> ReviewCommentSchema:
+def get_review_comment_from_bitbucket_pr_comment(comment: BitbucketCloudPRCommentSchema) -> ReviewCommentSchema:
     parent_id = comment.parent.id if comment.parent else None
     thread_id = parent_id or comment.id
 

ai_review/services/vcs/{bitbucket → bitbucket_cloud}/client.py

@@ -1,28 +1,31 @@
 from collections import defaultdict
 
-from ai_review.clients.bitbucket.client import get_bitbucket_http_client
-from ai_review.clients.bitbucket.pr.schema.comments import (
-    BitbucketCommentInlineSchema,
-    BitbucketCommentContentSchema,
-    BitbucketCreatePRCommentRequestSchema, BitbucketParentSchema,
+from ai_review.clients.bitbucket_cloud.client import get_bitbucket_cloud_http_client
+from ai_review.clients.bitbucket_cloud.pr.schema.comments import (
+    BitbucketCloudCommentParentSchema,
+    BitbucketCloudCommentInlineSchema,
+    BitbucketCloudCommentContentSchema,
+    BitbucketCloudCreatePRCommentRequestSchema,
 )
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
-from ai_review.services.vcs.bitbucket.adapter import get_review_comment_from_bitbucket_pr_comment
+from ai_review.services.vcs.bitbucket_cloud.adapter import get_review_comment_from_bitbucket_pr_comment
 from ai_review.services.vcs.types import (
     VCSClientProtocol,
+    ThreadKind,
     UserSchema,
     BranchRefSchema,
     ReviewInfoSchema,
-    ReviewCommentSchema, ReviewThreadSchema, ThreadKind,
+    ReviewThreadSchema,
+    ReviewCommentSchema,
 )
 
-logger = get_logger("BITBUCKET_VCS_CLIENT")
+logger = get_logger("BITBUCKET_CLOUD_VCS_CLIENT")
 
 
-class BitbucketVCSClient(VCSClientProtocol):
+class BitbucketCloudVCSClient(VCSClientProtocol):
     def __init__(self):
-        self.http_client = get_bitbucket_http_client()
+        self.http_client = get_bitbucket_cloud_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
@@ -129,8 +132,8 @@ class BitbucketVCSClient(VCSClientProtocol):
     async def create_general_comment(self, message: str) -> None:
         try:
             logger.info(f"Posting general comment to PR {self.pull_request_ref}: {message}")
-            request = BitbucketCreatePRCommentRequestSchema(
-                content=BitbucketCommentContentSchema(raw=message)
+            request = BitbucketCloudCreatePRCommentRequestSchema(
+                content=BitbucketCloudCommentContentSchema(raw=message)
             )
             await self.http_client.pr.create_comment(
                 workspace=self.workspace,
@@ -146,9 +149,9 @@ class BitbucketVCSClient(VCSClientProtocol):
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         try:
             logger.info(f"Posting inline comment in {self.pull_request_ref} at {file}:{line}: {message}")
-            request = BitbucketCreatePRCommentRequestSchema(
-                content=BitbucketCommentContentSchema(raw=message),
-                inline=BitbucketCommentInlineSchema(path=file, to_line=line),
+            request = BitbucketCloudCreatePRCommentRequestSchema(
+                content=BitbucketCloudCommentContentSchema(raw=message),
+                inline=BitbucketCloudCommentInlineSchema(path=file, to_line=line),
             )
             await self.http_client.pr.create_comment(
                 workspace=self.workspace,
@@ -165,9 +168,9 @@ class BitbucketVCSClient(VCSClientProtocol):
     async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
         try:
             logger.info(f"Replying to inline thread {thread_id=} in PR {self.pull_request_ref}")
-            request = BitbucketCreatePRCommentRequestSchema(
-                parent=BitbucketParentSchema(id=int(thread_id)),
-                content=BitbucketCommentContentSchema(raw=message),
+            request = BitbucketCloudCreatePRCommentRequestSchema(
+                parent=BitbucketCloudCommentParentSchema(id=int(thread_id)),
+                content=BitbucketCloudCommentContentSchema(raw=message),
             )
             await self.http_client.pr.create_comment(
                 workspace=self.workspace,
@@ -185,9 +188,9 @@ class BitbucketVCSClient(VCSClientProtocol):
     async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
         try:
             logger.info(f"Replying to summary thread {thread_id=} in PR {self.pull_request_ref}")
-            request = BitbucketCreatePRCommentRequestSchema(
-                content=BitbucketCommentContentSchema(raw=message),
-                parent=BitbucketParentSchema(id=int(thread_id)),
+            request = BitbucketCloudCreatePRCommentRequestSchema(
+                content=BitbucketCloudCommentContentSchema(raw=message),
+                parent=BitbucketCloudCommentParentSchema(id=int(thread_id)),
             )
             await self.http_client.pr.create_comment(
                 workspace=self.workspace,

ai_review/services/vcs/bitbucket_server/adapter.py

@@ -0,0 +1,27 @@
+from ai_review.clients.bitbucket_server.pr.schema.comments import BitbucketServerCommentSchema
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def get_review_comment_from_bitbucket_server_comment(comment: BitbucketServerCommentSchema) -> ReviewCommentSchema:
+    parent_id = None
+    thread_id = comment.id
+
+    user = comment.author
+    author = UserSchema(
+        id=user.id if user else None,
+        name=user.display_name or user.name or "",
+        username=user.slug or user.name or "",
+    )
+
+    file = comment.anchor.path if comment.anchor and comment.anchor.path else None
+    line = comment.anchor.line if comment.anchor else None
+
+    return ReviewCommentSchema(
+        id=comment.id,
+        body=comment.text or "",
+        file=file,
+        line=line,
+        author=author,
+        parent_id=parent_id,
+        thread_id=thread_id,
+    )

ai_review/services/vcs/bitbucket_server/client.py

@@ -0,0 +1,263 @@
+from collections import defaultdict
+
+from ai_review.clients.bitbucket_server.client import get_bitbucket_server_http_client
+from ai_review.clients.bitbucket_server.pr.schema.comments import (
+    BitbucketServerCommentAnchorSchema,
+    BitbucketServerCommentParentSchema,
+    BitbucketServerCreatePRCommentRequestSchema
+)
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.bitbucket_server.adapter import get_review_comment_from_bitbucket_server_comment
+from ai_review.services.vcs.types import (
+    VCSClientProtocol,
+    ThreadKind,
+    UserSchema,
+    BranchRefSchema,
+    ReviewInfoSchema,
+    ReviewThreadSchema,
+    ReviewCommentSchema,
+)
+
+logger = get_logger("BITBUCKET_SERVER_VCS_CLIENT")
+
+
+class BitbucketServerVCSClient(VCSClientProtocol):
+    def __init__(self):
+        self.http_client = get_bitbucket_server_http_client()
+        self.project_key = settings.vcs.pipeline.project_key
+        self.repo_slug = settings.vcs.pipeline.repo_slug
+        self.pull_request_id = settings.vcs.pipeline.pull_request_id
+        self.pull_request_ref = f"{self.project_key}/{self.repo_slug}#{self.pull_request_id}"
+
+    # --- Review info ---
+    async def get_review_info(self) -> ReviewInfoSchema:
+        try:
+            pr = await self.http_client.pr.get_pull_request(
+                project_key=self.project_key,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            changes = await self.http_client.pr.get_changes(
+                project_key=self.project_key,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+
+            logger.info(f"Fetched PR info for {self.pull_request_ref}")
+
+            return ReviewInfoSchema(
+                id=pr.id,
+                title=pr.title,
+                description=pr.description or "",
+                author=UserSchema(
+                    id=pr.author.user.id,
+                    name=pr.author.user.display_name,
+                    username=pr.author.user.slug or pr.author.user.name,
+                ),
+                labels=[],  # Bitbucket Server не поддерживает labels напрямую
+                base_sha=pr.to_ref.latest_commit,
+                head_sha=pr.from_ref.latest_commit,
+                assignees=[],  # нет отдельного поля в Bitbucket Server API
+                reviewers=[
+                    UserSchema(
+                        id=user.user.id,
+                        name=user.user.display_name,
+                        username=user.user.slug or user.user.name,
+                    )
+                    for user in pr.reviewers
+                ],
+                source_branch=BranchRefSchema(
+                    ref=pr.from_ref.display_id,
+                    sha=pr.from_ref.latest_commit,
+                ),
+                target_branch=BranchRefSchema(
+                    ref=pr.to_ref.display_id,
+                    sha=pr.to_ref.latest_commit,
+                ),
+                changed_files=[
+                    change.path.to_string
+                    for change in changes.values
+                    if change.path and change.path.to_string
+                ],
+            )
+        except Exception as error:
+            logger.exception(f"Failed to fetch PR info {self.pull_request_ref}: {error}")
+            return ReviewInfoSchema()
+
+    # --- Comments ---
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_comments(
+                project_key=self.project_key,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            logger.info(f"Fetched general comments for {self.pull_request_ref}")
+
+            return [
+                get_review_comment_from_bitbucket_server_comment(comment)
+                for comment in response.values
+                if comment.anchor is None  # нет привязки к файлу/строке — значит общий комментарий
+            ]
+        except Exception as error:
+            logger.exception(f"Failed to fetch general comments for {self.pull_request_ref}: {error}")
+            return []
+
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_comments(
+                project_key=self.project_key,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            logger.info(f"Fetched inline comments for {self.pull_request_ref}")
+
+            return [
+                get_review_comment_from_bitbucket_server_comment(comment)
+                for comment in response.values
+                if comment.anchor is not None and comment.anchor.path is not None
+            ]
+        except Exception as error:
+            logger.exception(f"Failed to fetch inline comments for {self.pull_request_ref}: {error}")
+            return []
+
+    async def create_general_comment(self, message: str) -> None:
+        try:
+            logger.info(f"Posting general comment to PR {self.pull_request_ref}: {message}")
+
+            request = BitbucketServerCreatePRCommentRequestSchema(text=message)
+
+            await self.http_client.pr.create_comment(
+                project_key=self.project_key,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+
+            logger.info(f"Created general comment in PR {self.pull_request_ref}")
+
+        except Exception as error:
+            logger.exception(f"Failed to create general comment in PR {self.pull_request_ref}: {error}")
+            raise
+
+    async def create_inline_comment(self, file: str, line: int, message: str) -> None:
+        try:
+            logger.info(f"Posting inline comment in {self.pull_request_ref} at {file}:{line}: {message}")
+
+            anchor = BitbucketServerCommentAnchorSchema(path=file, line=line, line_type="ADDED")
+            request = BitbucketServerCreatePRCommentRequestSchema(text=message, anchor=anchor)
+
+            await self.http_client.pr.create_comment(
+                project_key=self.project_key,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+
+            logger.info(f"Created inline comment in {self.pull_request_ref} at {file}:{line}")
+
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline comment in {self.pull_request_ref} at {file}:{line}: {error}")
+            raise
+
+    # --- Replies ---
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        try:
+            logger.info(f"Replying to inline thread {thread_id=} in PR {self.pull_request_ref}")
+            request = BitbucketServerCreatePRCommentRequestSchema(
+                text=message,
+                parent=BitbucketServerCommentParentSchema(id=int(thread_id)),
+            )
+            await self.http_client.pr.create_comment(
+                project_key=self.project_key,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+            logger.info(f"Created inline reply to thread {thread_id=} in PR {self.pull_request_ref}")
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline reply to thread {thread_id=} in PR {self.pull_request_ref}: {error}"
+            )
+            raise
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        try:
+            logger.info(f"Replying to summary thread {thread_id=} in PR {self.pull_request_ref}")
+            request = BitbucketServerCreatePRCommentRequestSchema(
+                text=message,
+                parent=BitbucketServerCommentParentSchema(id=int(thread_id)),
+            )
+            await self.http_client.pr.create_comment(
+                project_key=self.project_key,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+            logger.info(f"Created summary reply to thread {thread_id=} in PR {self.pull_request_ref}")
+        except Exception as error:
+            logger.exception(
+                f"Failed to create summary reply to thread {thread_id=} in PR {self.pull_request_ref}: {error}"
+            )
+            raise
+
+    # --- Threads ---
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_inline_comments()
+
+            threads_by_id: dict[str | int, list[ReviewCommentSchema]] = defaultdict(list)
+            for comment in comments:
+                if not comment.file:
+                    continue
+                threads_by_id[comment.thread_id].append(comment)
+
+            logger.info(f"Built {len(threads_by_id)} inline threads for {self.pull_request_ref}")
+
+            threads: list[ReviewThreadSchema] = []
+            for thread_id, thread in threads_by_id.items():
+                file = thread[0].file
+                line = thread[0].line
+                if not file:
+                    continue
+
+                threads.append(
+                    ReviewThreadSchema(
+                        id=thread_id,
+                        kind=ThreadKind.INLINE,
+                        file=file,
+                        line=line,
+                        comments=sorted(thread, key=lambda c: int(c.id)),
+                    )
+                )
+
+            return threads
+
+        except Exception as error:
+            logger.exception(f"Failed to fetch inline threads for {self.pull_request_ref}: {error}")
+            return []
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_general_comments()
+
+            threads_by_id: dict[str | int, list[ReviewCommentSchema]] = defaultdict(list)
+            for comment in comments:
+                threads_by_id[comment.thread_id].append(comment)
+
+            logger.info(f"Built {len(threads_by_id)} general threads for {self.pull_request_ref}")
+
+            return [
+                ReviewThreadSchema(
+                    id=thread_id,
+                    kind=ThreadKind.SUMMARY,
+                    comments=sorted(thread, key=lambda c: int(c.id)),
+                )
+                for thread_id, thread in threads_by_id.items()
+            ]
+
+        except Exception as error:
+            logger.exception(f"Failed to fetch general threads for {self.pull_request_ref}: {error}")
+            return []