xai-review 0.29.0__py3-none-any.whl → 0.31.0__py3-none-any.whl

ai_review/clients/gitea/client.py

@@ -0,0 +1,31 @@
+from ai_review.clients.gitea.pr.client import GiteaPullRequestsHTTPClient
+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 GiteaHTTPClient:
+    def __init__(self, client: AsyncClient):
+        self.pr = GiteaPullRequestsHTTPClient(client)
+
+
+def get_gitea_http_client() -> GiteaHTTPClient:
+    logger = get_logger("GITEA_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"token {settings.vcs.http_client.api_token_value}"},
+        base_url=settings.vcs.http_client.api_url_value.rstrip("/"),
+        transport=retry_transport,
+        event_hooks={
+            "request": [logger_event_hook.request],
+            "response": [logger_event_hook.response]
+        }
+    )
+
+    return GiteaHTTPClient(client=client)

ai_review/clients/gitea/pr/client.py

@@ -0,0 +1,118 @@
+from httpx import Response, QueryParams
+
+from ai_review.clients.gitea.pr.schema.comments import (
+    GiteaPRCommentSchema,
+    GiteaGetPRCommentsQuerySchema,
+    GiteaGetPRCommentsResponseSchema,
+    GiteaCreateCommentRequestSchema,
+    GiteaCreateCommentResponseSchema
+)
+from ai_review.clients.gitea.pr.schema.files import (
+    GiteaPRFileSchema,
+    GiteaGetPRFilesQuerySchema,
+    GiteaGetPRFilesResponseSchema
+)
+from ai_review.clients.gitea.pr.schema.pull_request import GiteaGetPRResponseSchema
+from ai_review.clients.gitea.pr.types import GiteaPullRequestsHTTPClientProtocol
+from ai_review.clients.gitea.tools import gitea_has_next_page
+from ai_review.config import settings
+from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.handlers import HTTPClientError, handle_http_error
+from ai_review.libs.http.paginate import paginate
+
+
+class GiteaPullRequestsHTTPClientError(HTTPClientError):
+    pass
+
+
+class GiteaPullRequestsHTTPClient(HTTPClient, GiteaPullRequestsHTTPClientProtocol):
+    @handle_http_error(client="GiteaPullRequestsHTTPClient", exception=GiteaPullRequestsHTTPClientError)
+    async def get_pull_request_api(self, owner: str, repo: str, pull_number: str) -> Response:
+        return await self.get(f"/repos/{owner}/{repo}/pulls/{pull_number}")
+
+    @handle_http_error(client="GiteaPullRequestsHTTPClient", exception=GiteaPullRequestsHTTPClientError)
+    async def get_files_api(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            query: GiteaGetPRFilesQuerySchema
+    ) -> Response:
+        return await self.get(
+            f"/repos/{owner}/{repo}/pulls/{pull_number}/files",
+            query=QueryParams(**query.model_dump())
+        )
+
+    @handle_http_error(client="GiteaPullRequestsHTTPClient", exception=GiteaPullRequestsHTTPClientError)
+    async def get_comments_api(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            query: GiteaGetPRCommentsQuerySchema
+    ) -> Response:
+        return await self.get(
+            f"/repos/{owner}/{repo}/issues/{pull_number}/comments",
+            query=QueryParams(**query.model_dump())
+        )
+
+    @handle_http_error(client="GiteaPullRequestsHTTPClient", exception=GiteaPullRequestsHTTPClientError)
+    async def create_comment_api(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            request: GiteaCreateCommentRequestSchema
+    ) -> Response:
+        return await self.post(
+            f"/repos/{owner}/{repo}/issues/{pull_number}/comments",
+            json=request.model_dump(),
+        )
+
+    async def get_pull_request(self, owner: str, repo: str, pull_number: str) -> GiteaGetPRResponseSchema:
+        response = await self.get_pull_request_api(owner, repo, pull_number)
+        return GiteaGetPRResponseSchema.model_validate_json(response.text)
+
+    async def get_files(self, owner: str, repo: str, pull_number: str) -> GiteaGetPRFilesResponseSchema:
+        async def fetch_page(page: int) -> Response:
+            query = GiteaGetPRFilesQuerySchema(page=page, per_page=settings.vcs.pagination.per_page)
+            return await self.get_files_api(owner, repo, pull_number, query)
+
+        def extract_items(response: Response) -> list[GiteaPRFileSchema]:
+            result = GiteaGetPRFilesResponseSchema.model_validate_json(response.text)
+            return result.root
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=gitea_has_next_page
+        )
+        return GiteaGetPRFilesResponseSchema(root=items)
+
+    async def get_comments(self, owner: str, repo: str, pull_number: str) -> GiteaGetPRCommentsResponseSchema:
+        async def fetch_page(page: int) -> Response:
+            query = GiteaGetPRCommentsQuerySchema(page=page, per_page=settings.vcs.pagination.per_page)
+            return await self.get_comments_api(owner, repo, pull_number, query)
+
+        def extract_items(response: Response) -> list[GiteaPRCommentSchema]:
+            result = GiteaGetPRCommentsResponseSchema.model_validate_json(response.text)
+            return result.root
+
+        items = await paginate(
+            max_pages=settings.vcs.pagination.max_pages,
+            fetch_page=fetch_page,
+            extract_items=extract_items,
+            has_next_page=gitea_has_next_page
+        )
+        return GiteaGetPRCommentsResponseSchema(root=items)
+
+    async def create_comment(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            request: GiteaCreateCommentRequestSchema
+    ) -> GiteaCreateCommentResponseSchema:
+        response = await self.create_comment_api(owner, repo, pull_number, request)
+        return GiteaCreateCommentResponseSchema.model_validate_json(response.text)

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

@@ -0,0 +1,37 @@
+from pydantic import BaseModel, RootModel
+
+from ai_review.clients.gitea.pr.schema.user import GiteaUserSchema
+
+
+class GiteaPRCommentSchema(BaseModel):
+    id: int
+    body: str
+    path: str | None = None
+    line: int | None = None
+    user: GiteaUserSchema | None = None
+    resolver: GiteaUserSchema | None = None
+    position: int | None = None
+    commit_id: str | None = None
+    original_position: int | None = None
+    original_commit_id: str | None = None
+    pull_request_review_id: int | None = None
+
+
+class GiteaGetPRCommentsQuerySchema(BaseModel):
+    page: int = 1
+    per_page: int = 100
+
+
+class GiteaGetPRCommentsResponseSchema(RootModel[list[GiteaPRCommentSchema]]):
+    root: list[GiteaPRCommentSchema]
+
+
+class GiteaCreateCommentRequestSchema(BaseModel):
+    body: str
+    path: str | None = None
+    line: int | None = None
+
+
+class GiteaCreateCommentResponseSchema(BaseModel):
+    id: int
+    body: str

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

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, RootModel
+
+
+class GiteaPRFileSchema(BaseModel):
+    patch: str | None = None
+    status: str
+    filename: str
+
+
+class GiteaGetPRFilesQuerySchema(BaseModel):
+    page: int = 1
+    per_page: int = 100
+
+
+class GiteaGetPRFilesResponseSchema(RootModel[list[GiteaPRFileSchema]]):
+    root: list[GiteaPRFileSchema]

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

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+
+from ai_review.clients.gitea.pr.schema.user import GiteaUserSchema
+
+
+class GiteaBranchSchema(BaseModel):
+    ref: str
+    sha: str
+
+
+class GiteaGetPRResponseSchema(BaseModel):
+    id: int
+    number: int
+    title: str
+    body: str | None = None
+    user: GiteaUserSchema
+    base: GiteaBranchSchema
+    head: GiteaBranchSchema

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

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class GiteaUserSchema(BaseModel):
+    id: int
+    login: str

ai_review/clients/gitea/pr/types.py

@@ -0,0 +1,25 @@
+from typing import Protocol
+
+from ai_review.clients.gitea.pr.schema.comments import (
+    GiteaCreateCommentRequestSchema,
+    GiteaCreateCommentResponseSchema,
+    GiteaGetPRCommentsResponseSchema
+)
+from ai_review.clients.gitea.pr.schema.files import GiteaGetPRFilesResponseSchema
+from ai_review.clients.gitea.pr.schema.pull_request import GiteaGetPRResponseSchema
+
+
+class GiteaPullRequestsHTTPClientProtocol(Protocol):
+    async def get_pull_request(self, owner: str, repo: str, pull_number: str) -> GiteaGetPRResponseSchema: ...
+
+    async def get_files(self, owner: str, repo: str, pull_number: str) -> GiteaGetPRFilesResponseSchema: ...
+
+    async def get_comments(self, owner: str, repo: str, pull_number: str) -> GiteaGetPRCommentsResponseSchema: ...
+
+    async def create_comment(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            request: GiteaCreateCommentRequestSchema
+    ) -> GiteaCreateCommentResponseSchema: ...

ai_review/clients/gitea/tools.py

@@ -0,0 +1,6 @@
+from httpx import Response
+
+
+def gitea_has_next_page(response: Response) -> bool:
+    link_header = response.headers.get("Link")
+    return link_header is not None and 'rel="next"' in link_header

ai_review/libs/config/review.py

@@ -19,6 +19,7 @@ class ReviewMode(StrEnum):
 
 class ReviewConfig(BaseModel):
     mode: ReviewMode = ReviewMode.FULL_FILE_DIFF
+    dry_run: bool = False
     inline_tag: str = Field(default="#ai-review-inline")
     inline_reply_tag: str = Field(default="#ai-review-inline-reply")
     summary_tag: str = Field(default="#ai-review-summary")

ai_review/libs/config/vcs/base.py

@@ -3,6 +3,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.gitea import GiteaPipelineConfig, GiteaHTTPClientConfig
 from ai_review.libs.config.vcs.github import GitHubPipelineConfig, GitHubHTTPClientConfig
 from ai_review.libs.config.vcs.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
 from ai_review.libs.config.vcs.pagination import VCSPaginationConfig
@@ -14,6 +15,12 @@ class VCSConfigBase(BaseModel):
     pagination: VCSPaginationConfig = VCSPaginationConfig()
 
 
+class GiteaVCSConfig(VCSConfigBase):
+    provider: Literal[VCSProvider.GITEA]
+    pipeline: GiteaPipelineConfig
+    http_client: GiteaHTTPClientConfig
+
+
 class GitLabVCSConfig(VCSConfigBase):
     provider: Literal[VCSProvider.GITLAB]
     pipeline: GitLabPipelineConfig
@@ -33,6 +40,6 @@ class BitbucketVCSConfig(VCSConfigBase):
 
 
 VCSConfig = Annotated[
-    GitLabVCSConfig | GitHubVCSConfig | BitbucketVCSConfig,
+    GiteaVCSConfig | GitLabVCSConfig | GitHubVCSConfig | BitbucketVCSConfig,
     Field(discriminator="provider")
 ]

ai_review/libs/config/vcs/gitea.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+from ai_review.libs.config.http import HTTPClientWithTokenConfig
+
+
+class GiteaPipelineConfig(BaseModel):
+    repo: str
+    owner: str
+    pull_number: str
+
+
+class GiteaHTTPClientConfig(HTTPClientWithTokenConfig):
+    pass

ai_review/libs/constants/vcs_provider.py

@@ -2,6 +2,7 @@ from enum import StrEnum
 
 
 class VCSProvider(StrEnum):
+    GITEA = "GITEA"
     GITHUB = "GITHUB"
     GITLAB = "GITLAB"
     BITBUCKET = "BITBUCKET"

ai_review/services/review/gateway/review_dry_run_comment_gateway.py

@@ -0,0 +1,42 @@
+from ai_review.libs.asynchronous.gather import bounded_gather
+from ai_review.libs.logger import get_logger
+from ai_review.services.hook import hook
+from ai_review.services.review.gateway.review_comment_gateway import ReviewCommentGateway
+from ai_review.services.review.internal.inline.schema import InlineCommentListSchema, InlineCommentSchema
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
+from ai_review.services.vcs.types import VCSClientProtocol
+
+logger = get_logger("REVIEW_DRY_RUN_COMMENT_GATEWAY")
+
+
+class ReviewDryRunCommentGateway(ReviewCommentGateway):
+    def __init__(self, vcs: VCSClientProtocol):
+        super().__init__(vcs)
+        logger.warning("Running in DRY RUN mode — no comments will be posted to VCS")
+
+    async def process_inline_reply(self, thread_id: str, reply: InlineCommentReplySchema) -> None:
+        await hook.emit_inline_comment_reply_start(reply)
+        logger.info(f"[dry-run] Would create inline reply for thread {thread_id}:\n{reply.body_with_tag}")
+        await hook.emit_inline_comment_reply_complete(reply)
+
+    async def process_summary_reply(self, thread_id: str, reply: SummaryCommentReplySchema) -> None:
+        await hook.emit_summary_comment_reply_start(reply)
+        logger.info(f"[dry-run] Would create summary reply for thread {thread_id}:\n{reply.body_with_tag}")
+        await hook.emit_summary_comment_reply_complete(reply)
+
+    async def process_inline_comment(self, comment: InlineCommentSchema) -> None:
+        await hook.emit_inline_comment_start(comment)
+        logger.info(
+            f"[dry-run] Would create inline comment for {comment.file}:{comment.line}:\n{comment.body_with_tag}"
+        )
+        await hook.emit_inline_comment_complete(comment)
+
+    async def process_summary_comment(self, comment: SummaryCommentSchema) -> None:
+        await hook.emit_summary_comment_start(comment)
+        logger.info(f"[dry-run] Would create summary comment:\n{comment.body_with_tag}")
+        await hook.emit_summary_comment_complete(comment)
+
+    async def process_inline_comments(self, comments: InlineCommentListSchema) -> None:
+        await bounded_gather([self.process_inline_comment(comment) for comment in comments.root])

ai_review/services/review/service.py

@@ -1,3 +1,4 @@
+from ai_review.config import settings
 from ai_review.libs.logger import get_logger
 from ai_review.services.artifacts.service import ArtifactsService
 from ai_review.services.cost.service import CostService
@@ -5,8 +6,9 @@ from ai_review.services.diff.service import DiffService
 from ai_review.services.git.service import GitService
 from ai_review.services.llm.factory import get_llm_client
 from ai_review.services.prompt.service import PromptService
-from ai_review.services.review.gateway.comment import ReviewCommentGateway
-from ai_review.services.review.gateway.llm import ReviewLLMGateway
+from ai_review.services.review.gateway.review_comment_gateway import ReviewCommentGateway
+from ai_review.services.review.gateway.review_dry_run_comment_gateway import ReviewDryRunCommentGateway
+from ai_review.services.review.gateway.review_llm_gateway import ReviewLLMGateway
 from ai_review.services.review.internal.inline.service import InlineCommentService
 from ai_review.services.review.internal.inline_reply.service import InlineCommentReplyService
 from ai_review.services.review.internal.policy.service import ReviewPolicyService
@@ -42,7 +44,11 @@ class ReviewService:
             cost=self.cost,
             artifacts=self.artifacts
         )
-        self.review_comment_gateway = ReviewCommentGateway(vcs=self.vcs)
+        self.review_comment_gateway = (
+            ReviewDryRunCommentGateway(vcs=self.vcs)
+            if settings.review.dry_run
+            else ReviewCommentGateway(vcs=self.vcs)
+        )
 
         self.inline_review_runner = InlineReviewRunner(
             vcs=self.vcs,

ai_review/services/vcs/factory.py

@@ -1,6 +1,7 @@
 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.gitea.client import GiteaVCSClient
 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
@@ -8,6 +9,8 @@ from ai_review.services.vcs.types import VCSClientProtocol
 
 def get_vcs_client() -> VCSClientProtocol:
     match settings.vcs.provider:
+        case VCSProvider.GITEA:
+            return GiteaVCSClient()
         case VCSProvider.GITLAB:
             return GitLabVCSClient()
         case VCSProvider.GITHUB:

ai_review/services/vcs/gitea/adapter.py

@@ -0,0 +1,22 @@
+from ai_review.clients.gitea.pr.schema.comments import GiteaPRCommentSchema
+from ai_review.clients.gitea.pr.schema.pull_request import GiteaUserSchema
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def get_user_from_gitea_user(user: GiteaUserSchema | None) -> UserSchema:
+    return UserSchema(
+        id=user.id if user else None,
+        name=user.login if user else "",
+        username=user.login if user else "",
+    )
+
+
+def get_review_comment_from_gitea_comment(comment: GiteaPRCommentSchema) -> ReviewCommentSchema:
+    return ReviewCommentSchema(
+        id=comment.id,
+        body=comment.body or "",
+        file=comment.path,
+        line=comment.line,
+        author=get_user_from_gitea_user(comment.user),
+        thread_id=comment.id
+    )

ai_review/services/vcs/gitea/client.py

@@ -0,0 +1,151 @@
+from ai_review.clients.gitea.client import get_gitea_http_client
+from ai_review.clients.gitea.pr.schema.comments import GiteaCreateCommentRequestSchema
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.gitea.adapter import get_review_comment_from_gitea_comment, get_user_from_gitea_user
+from ai_review.services.vcs.types import (
+    VCSClientProtocol,
+    ThreadKind,
+    BranchRefSchema,
+    ReviewInfoSchema,
+    ReviewThreadSchema,
+    ReviewCommentSchema,
+)
+
+logger = get_logger("GITEA_VCS_CLIENT")
+
+
+class GiteaVCSClient(VCSClientProtocol):
+    def __init__(self):
+        self.http_client = get_gitea_http_client()
+        self.owner = settings.vcs.pipeline.owner
+        self.repo = settings.vcs.pipeline.repo
+        self.pull_number = settings.vcs.pipeline.pull_number
+        self.pull_request_ref = f"{self.owner}/{self.repo}#{self.pull_number}"
+
+    # --- Review info ---
+    async def get_review_info(self) -> ReviewInfoSchema:
+        try:
+            pr = await self.http_client.pr.get_pull_request(
+                owner=self.owner, repo=self.repo, pull_number=self.pull_number
+            )
+            files = await self.http_client.pr.get_files(
+                owner=self.owner, repo=self.repo, pull_number=self.pull_number
+            )
+
+            logger.info(f"Fetched PR info for {self.pull_request_ref}")
+
+            return ReviewInfoSchema(
+                id=pr.number,
+                title=pr.title,
+                description=pr.body or "",
+                author=get_user_from_gitea_user(pr.user),
+                labels=[],
+                base_sha=pr.base.sha,
+                head_sha=pr.head.sha,
+                assignees=[],
+                reviewers=[],
+                source_branch=BranchRefSchema(ref=pr.head.ref, sha=pr.head.sha),
+                target_branch=BranchRefSchema(ref=pr.base.ref, sha=pr.base.sha),
+                changed_files=[file.filename for file in files.root],
+            )
+        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(
+                owner=self.owner, repo=self.repo, pull_number=self.pull_number
+            )
+            logger.info(f"Fetched comments for {self.pull_request_ref}")
+
+            return [get_review_comment_from_gitea_comment(comment) for comment in response.root]
+        except Exception as error:
+            logger.exception(f"Failed to fetch comments for {self.pull_request_ref}: {error}")
+            return []
+
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            comments = await self.get_general_comments()
+            return [comment for comment in comments if comment.file]
+        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 = GiteaCreateCommentRequestSchema(body=message)
+            await self.http_client.pr.create_comment(
+                owner=self.owner,
+                repo=self.repo,
+                pull_number=self.pull_number,
+                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 to {self.pull_request_ref} at {file}:{line}")
+            request = GiteaCreateCommentRequestSchema(
+                body=message,
+                path=file,
+                line=line,
+            )
+            await self.http_client.pr.create_comment(
+                owner=self.owner,
+                repo=self.repo,
+                pull_number=self.pull_number,
+                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
+
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        await self.create_general_comment(message)
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        await self.create_general_comment(message)
+
+    # --- Threads ---
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_inline_comments()
+            threads = {comment.thread_id: [comment] for comment in comments}
+
+            return [
+                ReviewThreadSchema(
+                    id=thread_id,
+                    kind=ThreadKind.INLINE,
+                    file=thread[0].file,
+                    line=thread[0].line,
+                    comments=thread,
+                )
+                for thread_id, thread in threads.items()
+            ]
+        except Exception as error:
+            logger.exception(f"Failed to build 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 = [
+                ReviewThreadSchema(
+                    id=comment.thread_id,
+                    kind=ThreadKind.SUMMARY,
+                    comments=[comment]
+                )
+                for comment in comments
+            ]
+            return threads
+        except Exception as error:
+            logger.exception(f"Failed to build general threads for {self.pull_request_ref}: {error}")
+            return []