xai-review 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

ai_review/services/review/runner/summary.py

@@ -0,0 +1,71 @@
+from ai_review.libs.logger import get_logger
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.diff.types import DiffServiceProtocol
+from ai_review.services.git.types import GitServiceProtocol
+from ai_review.services.hook import hook
+from ai_review.services.prompt.adapter import build_prompt_context_from_review_info
+from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.review.gateway.types import ReviewLLMGatewayProtocol, ReviewCommentGatewayProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.internal.summary.types import SummaryCommentServiceProtocol
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol
+
+logger = get_logger("SUMMARY_REVIEW_RUNNER")
+
+
+class SummaryReviewRunner(ReviewRunnerProtocol):
+    def __init__(
+            self,
+            vcs: VCSClientProtocol,
+            git: GitServiceProtocol,
+            diff: DiffServiceProtocol,
+            cost: CostServiceProtocol,
+            prompt: PromptServiceProtocol,
+            review_policy: ReviewPolicyServiceProtocol,
+            summary_comment: SummaryCommentServiceProtocol,
+            review_llm_gateway: ReviewLLMGatewayProtocol,
+            review_comment_gateway: ReviewCommentGatewayProtocol,
+    ):
+        self.vcs = vcs
+        self.git = git
+        self.diff = diff
+        self.cost = cost
+        self.prompt = prompt
+        self.review_policy = review_policy
+        self.summary_comment = summary_comment
+        self.review_llm_gateway = review_llm_gateway
+        self.review_comment_gateway = review_comment_gateway
+
+    async def run(self) -> None:
+        await hook.emit_summary_review_start()
+        if await self.review_comment_gateway.has_existing_summary_comments():
+            return
+
+        review_info = await self.vcs.get_review_info()
+        changed_files = self.review_policy.apply_for_files(review_info.changed_files)
+        if not changed_files:
+            logger.info("No files to review for summary")
+            return
+
+        logger.info(f"Starting summary review: {len(changed_files)} files changed")
+
+        rendered_files = self.diff.render_files(
+            git=self.git,
+            files=changed_files,
+            base_sha=review_info.base_sha,
+            head_sha=review_info.head_sha,
+        )
+        prompt_context = build_prompt_context_from_review_info(review_info)
+        prompt = self.prompt.build_summary_request(rendered_files, prompt_context)
+        prompt_system = self.prompt.build_system_summary_request(prompt_context)
+        prompt_result = await self.review_llm_gateway.ask(prompt, prompt_system)
+
+        summary = self.summary_comment.parse_model_output(prompt_result)
+        if not summary.text.strip():
+            logger.warning("Summary LLM output was empty, skipping comment")
+            return
+
+        logger.info(f"Posting summary review comment ({len(summary.text)} chars)")
+        await self.review_comment_gateway.process_summary_comment(summary)
+        await hook.emit_summary_review_complete(self.cost.aggregate())

ai_review/services/review/runner/summary_reply.py

@@ -0,0 +1,79 @@
+from ai_review.libs.asynchronous.gather import bounded_gather
+from ai_review.libs.logger import get_logger
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.diff.types import DiffServiceProtocol
+from ai_review.services.git.types import GitServiceProtocol
+from ai_review.services.hook import hook
+from ai_review.services.prompt.adapter import build_prompt_context_from_review_info
+from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.review.gateway.types import ReviewCommentGatewayProtocol, ReviewLLMGatewayProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.internal.summary_reply.types import SummaryCommentReplyServiceProtocol
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import VCSClientProtocol, ReviewThreadSchema, ReviewInfoSchema
+
+logger = get_logger("SUMMARY_REPLY_REVIEW_RUNNER")
+
+
+class SummaryReplyReviewRunner(ReviewRunnerProtocol):
+    def __init__(
+            self,
+            vcs: VCSClientProtocol,
+            git: GitServiceProtocol,
+            diff: DiffServiceProtocol,
+            cost: CostServiceProtocol,
+            prompt: PromptServiceProtocol,
+            review_policy: ReviewPolicyServiceProtocol,
+            review_llm_gateway: ReviewLLMGatewayProtocol,
+            summary_comment_reply: SummaryCommentReplyServiceProtocol,
+            review_comment_gateway: ReviewCommentGatewayProtocol,
+    ):
+        self.vcs = vcs
+        self.git = git
+        self.diff = diff
+        self.cost = cost
+        self.prompt = prompt
+        self.review_policy = review_policy
+        self.review_llm_gateway = review_llm_gateway
+        self.summary_comment_reply = summary_comment_reply
+        self.review_comment_gateway = review_comment_gateway
+
+    async def process_thread_reply(self, thread: ReviewThreadSchema, review_info: ReviewInfoSchema):
+        logger.info(f"Processing summary reply for thread {thread.id}")
+
+        changed_files = self.review_policy.apply_for_files(review_info.changed_files)
+        if not changed_files:
+            logger.info("No files to review for summary")
+            return
+
+        rendered_files = self.diff.render_files(
+            git=self.git,
+            files=changed_files,
+            base_sha=review_info.base_sha,
+            head_sha=review_info.head_sha,
+        )
+        prompt_context = build_prompt_context_from_review_info(review_info)
+        prompt = self.prompt.build_summary_reply_request(rendered_files, thread, prompt_context)
+        prompt_system = self.prompt.build_system_summary_reply_request(prompt_context)
+        prompt_result = await self.review_llm_gateway.ask(prompt, prompt_system)
+
+        reply = self.summary_comment_reply.parse_model_output(prompt_result)
+        if not reply:
+            logger.info(f"No valid reply generated for summary thread {thread.id}")
+            return
+
+        await self.review_comment_gateway.process_summary_reply(thread.id, reply)
+
+    async def run(self) -> None:
+        await hook.emit_summary_reply_review_start()
+
+        review_info = await self.vcs.get_review_info()
+        threads = await self.review_comment_gateway.get_summary_threads()
+        if not threads:
+            logger.info("No AI summary threads found, skipping summary reply mode")
+            return
+
+        logger.info(f"Found {len(threads)} AI summary threads for reply")
+
+        await bounded_gather([self.process_thread_reply(thread, review_info) for thread in threads])
+        await hook.emit_summary_reply_review_complete(self.cost.aggregate())

ai_review/services/review/runner/types.py

@@ -0,0 +1,6 @@
+from typing import Protocol
+
+
+class ReviewRunnerProtocol(Protocol):
+    async def run(self) -> None:
+        ...

ai_review/services/review/service.py

@@ -1,20 +1,23 @@
-from ai_review.libs.asynchronous.gather import bounded_gather
 from ai_review.libs.logger import get_logger
 from ai_review.services.artifacts.service import ArtifactsService
 from ai_review.services.cost.service import CostService
 from ai_review.services.diff.service import DiffService
 from ai_review.services.git.service import GitService
-from ai_review.services.hook import hook
 from ai_review.services.llm.factory import get_llm_client
-from ai_review.services.prompt.adapter import build_prompt_context_from_mr_info
 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.inline.service import InlineCommentService
-from ai_review.services.review.policy.service import ReviewPolicyService
-from ai_review.services.review.summary.service import SummaryCommentService
+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
+from ai_review.services.review.internal.summary.service import SummaryCommentService
+from ai_review.services.review.internal.summary_reply.service import SummaryCommentReplyService
+from ai_review.services.review.runner.context import ContextReviewRunner
+from ai_review.services.review.runner.inline import InlineReviewRunner
+from ai_review.services.review.runner.inline_reply import InlineReplyReviewRunner
+from ai_review.services.review.runner.summary import SummaryReviewRunner
+from ai_review.services.review.runner.summary_reply import SummaryReplyReviewRunner
 from ai_review.services.vcs.factory import get_vcs_client
-from ai_review.services.vcs.types import ReviewInfoSchema
 
 logger = get_logger("REVIEW_SERVICE")
 
@@ -27,125 +30,90 @@ class ReviewService:
         self.diff = DiffService()
         self.cost = CostService()
         self.prompt = PromptService()
-        self.policy = ReviewPolicyService()
-        self.inline = InlineCommentService()
-        self.summary = SummaryCommentService()
         self.artifacts = ArtifactsService()
+        self.review_policy = ReviewPolicyService()
+        self.inline_comment = InlineCommentService()
+        self.summary_comment = SummaryCommentService()
+        self.inline_comment_reply = InlineCommentReplyService()
+        self.summary_comment_reply = SummaryCommentReplyService()
 
-        self.llm_gateway = ReviewLLMGateway(
+        self.review_llm_gateway = ReviewLLMGateway(
             llm=self.llm,
             cost=self.cost,
             artifacts=self.artifacts
         )
-        self.comment_gateway = ReviewCommentGateway(vcs=self.vcs)
+        self.review_comment_gateway = ReviewCommentGateway(vcs=self.vcs)
 
-    async def process_file_inline(self, file: str, review_info: ReviewInfoSchema) -> None:
-        raw_diff = self.git.get_diff_for_file(review_info.base_sha, review_info.head_sha, file)
-        if not raw_diff.strip():
-            logger.debug(f"No diff for {file}, skipping")
-            return
-
-        rendered_file = self.diff.render_file(
-            file=file,
-            base_sha=review_info.base_sha,
-            head_sha=review_info.head_sha,
-            raw_diff=raw_diff,
+        self.inline_review_runner = InlineReviewRunner(
+            vcs=self.vcs,
+            git=self.git,
+            diff=self.diff,
+            cost=self.cost,
+            prompt=self.prompt,
+            review_policy=self.review_policy,
+            inline_comment=self.inline_comment,
+            review_llm_gateway=self.review_llm_gateway,
+            review_comment_gateway=self.review_comment_gateway
         )
-        prompt_context = build_prompt_context_from_mr_info(review_info)
-        prompt = self.prompt.build_inline_request(rendered_file, prompt_context)
-        prompt_system = self.prompt.build_system_inline_request(prompt_context)
-        prompt_result = await self.llm_gateway.ask(prompt, prompt_system)
-
-        comments = self.inline.parse_model_output(prompt_result).dedupe()
-        comments.root = self.policy.apply_for_inline_comments(comments.root)
-        if not comments.root:
-            logger.info(f"No inline comments for file: {file}")
-            return
-
-        logger.info(f"Posting {len(comments.root)} inline comments to {file}")
-        await self.comment_gateway.process_inline_comments(comments)
-
-    async def run_inline_review(self) -> None:
-        await hook.emit_inline_review_start()
-        if await self.comment_gateway.has_existing_inline_comments():
-            return
-
-        review_info = await self.vcs.get_review_info()
-        logger.info(f"Starting inline review: {len(review_info.changed_files)} files changed")
-
-        changed_files = self.policy.apply_for_files(review_info.changed_files)
-        await bounded_gather([
-            self.process_file_inline(changed_file, review_info)
-            for changed_file in changed_files
-        ])
-        await hook.emit_inline_review_complete(self.cost.aggregate())
-
-    async def run_context_review(self) -> None:
-        await hook.emit_context_review_start()
-        if await self.comment_gateway.has_existing_inline_comments():
-            return
-
-        review_info = await self.vcs.get_review_info()
-        changed_files = self.policy.apply_for_files(review_info.changed_files)
-        if not changed_files:
-            logger.info("No files to review for context review")
-            return
-
-        logger.info(f"Starting context inline review: {len(changed_files)} files changed")
-
-        rendered_files = self.diff.render_files(
+        self.context_review_runner = ContextReviewRunner(
+            vcs=self.vcs,
             git=self.git,
-            files=changed_files,
-            base_sha=review_info.base_sha,
-            head_sha=review_info.head_sha,
+            diff=self.diff,
+            cost=self.cost,
+            prompt=self.prompt,
+            review_policy=self.review_policy,
+            inline_comment=self.inline_comment,
+            review_llm_gateway=self.review_llm_gateway,
+            review_comment_gateway=self.review_comment_gateway
+        )
+        self.summary_review_runner = SummaryReviewRunner(
+            vcs=self.vcs,
+            git=self.git,
+            diff=self.diff,
+            cost=self.cost,
+            prompt=self.prompt,
+            review_policy=self.review_policy,
+            summary_comment=self.summary_comment,
+            review_llm_gateway=self.review_llm_gateway,
+            review_comment_gateway=self.review_comment_gateway
+        )
+        self.inline_reply_review_runner = InlineReplyReviewRunner(
+            vcs=self.vcs,
+            git=self.git,
+            diff=self.diff,
+            cost=self.cost,
+            prompt=self.prompt,
+            review_policy=self.review_policy,
+            review_llm_gateway=self.review_llm_gateway,
+            inline_comment_reply=self.inline_comment_reply,
+            review_comment_gateway=self.review_comment_gateway
+        )
+        self.summary_reply_review_runner = SummaryReplyReviewRunner(
+            vcs=self.vcs,
+            git=self.git,
+            diff=self.diff,
+            cost=self.cost,
+            prompt=self.prompt,
+            review_policy=self.review_policy,
+            review_llm_gateway=self.review_llm_gateway,
+            summary_comment_reply=self.summary_comment_reply,
+            review_comment_gateway=self.review_comment_gateway
         )
-        prompt_context = build_prompt_context_from_mr_info(review_info)
-        prompt = self.prompt.build_context_request(rendered_files, prompt_context)
-        prompt_system = self.prompt.build_system_context_request(prompt_context)
-        prompt_result = await self.llm_gateway.ask(prompt, prompt_system)
 
-        comments = self.inline.parse_model_output(prompt_result).dedupe()
-        comments.root = self.policy.apply_for_context_comments(comments.root)
-        if not comments.root:
-            logger.info("No inline comments from context review")
-            return
+    async def run_inline_review(self) -> None:
+        await self.inline_review_runner.run()
 
-        logger.info(f"Posting {len(comments.root)} inline comments (context review)")
-        await self.comment_gateway.process_inline_comments(comments)
-        await hook.emit_context_review_complete(self.cost.aggregate())
+    async def run_context_review(self) -> None:
+        await self.context_review_runner.run()
 
     async def run_summary_review(self) -> None:
-        await hook.emit_summary_review_start()
-        if await self.comment_gateway.has_existing_summary_comments():
-            return
-
-        review_info = await self.vcs.get_review_info()
-        changed_files = self.policy.apply_for_files(review_info.changed_files)
-        if not changed_files:
-            logger.info("No files to review for summary")
-            return
-
-        logger.info(f"Starting summary review: {len(changed_files)} files changed")
-
-        rendered_files = self.diff.render_files(
-            git=self.git,
-            files=changed_files,
-            base_sha=review_info.base_sha,
-            head_sha=review_info.head_sha,
-        )
-        prompt_context = build_prompt_context_from_mr_info(review_info)
-        prompt = self.prompt.build_summary_request(rendered_files, prompt_context)
-        prompt_system = self.prompt.build_system_summary_request(prompt_context)
-        prompt_result = await self.llm_gateway.ask(prompt, prompt_system)
+        await self.summary_review_runner.run()
 
-        summary = self.summary.parse_model_output(prompt_result)
-        if not summary.text.strip():
-            logger.warning("Summary LLM output was empty, skipping comment")
-            return
+    async def run_inline_reply_review(self) -> None:
+        await self.inline_reply_review_runner.run()
 
-        logger.info(f"Posting summary review comment ({len(summary.text)} chars)")
-        await self.comment_gateway.process_summary_comment(summary)
-        await hook.emit_summary_review_complete(self.cost.aggregate())
+    async def run_summary_reply_review(self) -> None:
+        await self.summary_reply_review_runner.run()
 
     def report_total_cost(self):
         total_report = self.cost.aggregate()

ai_review/services/vcs/bitbucket/adapter.py

@@ -0,0 +1,24 @@
+from ai_review.clients.bitbucket.pr.schema.comments import BitbucketPRCommentSchema
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def get_review_comment_from_bitbucket_pr_comment(comment: BitbucketPRCommentSchema) -> ReviewCommentSchema:
+    parent_id = comment.parent.id if comment.parent else None
+    thread_id = parent_id or comment.id
+
+    user = comment.user
+    author = UserSchema(
+        id=user.uuid if user else None,
+        name=user.display_name if user else "",
+        username=user.nickname if user else "",
+    )
+
+    return ReviewCommentSchema(
+        id=comment.id,
+        body=comment.content.raw or "",
+        file=comment.inline.path if comment.inline else None,
+        line=comment.inline.to_line if comment.inline else None,
+        author=author,
+        parent_id=parent_id,
+        thread_id=thread_id,
+    )

ai_review/services/vcs/bitbucket/client.py

@@ -1,17 +1,20 @@
+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,
+    BitbucketCreatePRCommentRequestSchema, BitbucketParentSchema,
 )
 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.types import (
     VCSClientProtocol,
     UserSchema,
     BranchRefSchema,
     ReviewInfoSchema,
-    ReviewCommentSchema,
+    ReviewCommentSchema, ReviewThreadSchema, ThreadKind,
 )
 
 logger = get_logger("BITBUCKET_VCS_CLIENT")
@@ -23,7 +26,9 @@ class BitbucketVCSClient(VCSClientProtocol):
         self.workspace = settings.vcs.pipeline.workspace
         self.repo_slug = settings.vcs.pipeline.repo_slug
         self.pull_request_id = settings.vcs.pipeline.pull_request_id
+        self.pull_request_ref = f"{self.workspace}/{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(
@@ -37,7 +42,7 @@ class BitbucketVCSClient(VCSClientProtocol):
                 pull_request_id=self.pull_request_id,
             )
 
-            logger.info(f"Fetched PR info for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+            logger.info(f"Fetched PR info for {self.pull_request_ref}")
 
             return ReviewInfoSchema(
                 id=pr.id,
@@ -81,11 +86,10 @@ class BitbucketVCSClient(VCSClientProtocol):
                 ],
             )
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch PR info {self.workspace}/{self.repo_slug}#{self.pull_request_id}: {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(
@@ -93,18 +97,15 @@ class BitbucketVCSClient(VCSClientProtocol):
                 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}")
+            logger.info(f"Fetched general comments for {self.pull_request_ref}")
 
             return [
-                ReviewCommentSchema(id=comment.id, body=comment.content.raw)
+                get_review_comment_from_bitbucket_pr_comment(comment)
                 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}"
-            )
+            logger.exception(f"Failed to fetch general comments for {self.pull_request_ref}: {error}")
             return []
 
     async def get_inline_comments(self) -> list[ReviewCommentSchema]:
@@ -114,30 +115,20 @@ class BitbucketVCSClient(VCSClientProtocol):
                 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}")
+            logger.info(f"Fetched inline comments for {self.pull_request_ref}")
 
             return [
-                ReviewCommentSchema(
-                    id=comment.id,
-                    body=comment.content.raw,
-                    file=comment.inline.path,
-                    line=comment.inline.to_line,
-                )
+                get_review_comment_from_bitbucket_pr_comment(comment)
                 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}"
-            )
+            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.workspace}/{self.repo_slug}#{self.pull_request_id}: {message}"
-            )
+            logger.info(f"Posting general comment to PR {self.pull_request_ref}: {message}")
             request = BitbucketCreatePRCommentRequestSchema(
                 content=BitbucketCommentContentSchema(raw=message)
             )
@@ -147,22 +138,14 @@ class BitbucketVCSClient(VCSClientProtocol):
                 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}"
-            )
+            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 "
-                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {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.workspace}/{self.repo_slug}#{self.pull_request_id} "
-                f"at {file}:{line}: {message}"
-            )
+            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),
@@ -173,13 +156,95 @@ class BitbucketVCSClient(VCSClientProtocol):
                 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}"
+            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 = BitbucketCreatePRCommentRequestSchema(
+                parent=BitbucketParentSchema(id=int(thread_id)),
+                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 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 = BitbucketCreatePRCommentRequestSchema(
+                content=BitbucketCommentContentSchema(raw=message),
+                parent=BitbucketParentSchema(id=int(thread_id)),
+            )
+            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 summary reply to thread {thread_id=} in PR {self.pull_request_ref}")
         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}"
+                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: dict[str | int, list[ReviewCommentSchema]] = defaultdict(list)
+            for comment in comments:
+                threads[comment.thread_id].append(comment)
+
+            logger.info(f"Built {len(threads)} inline threads for {self.pull_request_ref}")
+
+            return [
+                ReviewThreadSchema(
+                    id=thread_id,
+                    kind=ThreadKind.INLINE,
+                    file=thread[0].file,
+                    line=thread[0].line,
+                    comments=sorted(thread, key=lambda c: int(c.id)),
+                )
+                for thread_id, thread in threads.items()
+            ]
+        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: dict[str | int, list[ReviewCommentSchema]] = defaultdict(list)
+            for comment in comments:
+                threads[comment.thread_id].append(comment)
+
+            logger.info(f"Built {len(threads)} 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.items()
+            ]
+        except Exception as error:
+            logger.exception(f"Failed to fetch general threads for {self.pull_request_ref}: {error}")
+            return []