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

ai_review/services/review/runner/inline_reply.py

@@ -0,0 +1,80 @@
+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.inline_reply.types import InlineCommentReplyServiceProtocol
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
+from ai_review.services.review.runner.types import ReviewRunnerProtocol
+from ai_review.services.vcs.types import ReviewInfoSchema, VCSClientProtocol, ReviewThreadSchema
+
+logger = get_logger("INLINE_REPLY_REVIEW_RUNNER")
+
+
+class InlineReplyReviewRunner(ReviewRunnerProtocol):
+    def __init__(
+            self,
+            vcs: VCSClientProtocol,
+            git: GitServiceProtocol,
+            diff: DiffServiceProtocol,
+            cost: CostServiceProtocol,
+            prompt: PromptServiceProtocol,
+            review_policy: ReviewPolicyServiceProtocol,
+            review_llm_gateway: ReviewLLMGatewayProtocol,
+            inline_comment_reply: InlineCommentReplyServiceProtocol,
+            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.inline_comment_reply = inline_comment_reply
+        self.review_comment_gateway = review_comment_gateway
+
+    async def process_thread_reply(self, thread: ReviewThreadSchema, review_info: ReviewInfoSchema):
+        logger.info(f"Processing inline reply for thread {thread.id}")
+
+        raw_diff = self.git.get_diff_for_file(review_info.base_sha, review_info.head_sha, thread.file)
+        if not raw_diff.strip():
+            logger.debug(f"No diff for {thread.file}, skipping")
+            return
+
+        rendered_file = self.diff.render_file(
+            file=thread.file,
+            base_sha=review_info.base_sha,
+            head_sha=review_info.head_sha,
+            raw_diff=raw_diff
+        )
+
+        prompt_context = build_prompt_context_from_review_info(review_info)
+        prompt = self.prompt.build_inline_reply_request(rendered_file, thread, prompt_context)
+        prompt_system = self.prompt.build_system_inline_reply_request(prompt_context)
+        prompt_result = await self.review_llm_gateway.ask(prompt, prompt_system)
+
+        reply = self.inline_comment_reply.parse_model_output(prompt_result)
+        if not reply:
+            logger.info(f"AI model returned no valid reply for thread {thread.id} ({len(thread.comments)} comments)")
+            return
+
+        await self.review_comment_gateway.process_inline_reply(thread.id, reply)
+
+    async def run(self) -> None:
+        await hook.emit_inline_reply_review_start()
+
+        review_info = await self.vcs.get_review_info()
+        threads = await self.review_comment_gateway.get_inline_threads()
+        if not threads:
+            logger.info("No AI inline threads found, skipping reply mode")
+            return
+
+        logger.info(f"Found {len(threads)} AI inline threads for reply")
+
+        await bounded_gather([self.process_thread_reply(thread, review_info) for thread in threads])
+        await hook.emit_inline_reply_review_complete(self.cost.aggregate())

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,27 @@
+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 "",
+    )
+
+    file = comment.inline.path if comment.inline and comment.inline.path else None
+    line = comment.inline.to_line if comment.inline else None
+
+    return ReviewCommentSchema(
+        id=comment.id,
+        body=comment.content.raw or "",
+        file=file,
+        line=line,
+        author=author,
+        parent_id=parent_id,
+        thread_id=thread_id,
+    )