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

ai_review/services/review/internal/policy/types.py

@@ -0,0 +1,15 @@
+from typing import Protocol
+
+
+class ReviewPolicyServiceProtocol(Protocol):
+    def should_review_file(self, file: str) -> bool:
+        ...
+
+    def apply_for_files(self, files: list[str]) -> list[str]:
+        ...
+
+    def apply_for_inline_comments(self, comments: list) -> list:
+        ...
+
+    def apply_for_context_comments(self, comments: list) -> list:
+        ...

ai_review/services/review/{summary → internal/summary}/service.py

@@ -1,6 +1,6 @@
 from ai_review.libs.logger import get_logger
-from ai_review.services.review.summary.schema import SummaryCommentSchema
-from ai_review.services.review.summary.types import SummaryCommentServiceProtocol
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.summary.types import SummaryCommentServiceProtocol
 
 logger = get_logger("SUMMARY_COMMENT_SERVICE")
 

ai_review/services/review/{summary → internal/summary}/types.py

@@ -1,6 +1,6 @@
 from typing import Protocol
 
-from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
 
 
 class SummaryCommentServiceProtocol(Protocol):

ai_review/services/review/internal/summary_reply/schema.py

@@ -0,0 +1,8 @@
+from ai_review.config import settings
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
+
+
+class SummaryCommentReplySchema(SummaryCommentSchema):
+    @property
+    def body_with_tag(self):
+        return f"{self.text}\n\n{settings.review.summary_reply_tag}"

ai_review/services/review/internal/summary_reply/service.py

@@ -0,0 +1,15 @@
+from ai_review.libs.logger import get_logger
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
+from ai_review.services.review.internal.summary_reply.types import SummaryCommentReplyServiceProtocol
+
+logger = get_logger("SUMMARY_COMMENT_REPLY_SERVICE")
+
+
+class SummaryCommentReplyService(SummaryCommentReplyServiceProtocol):
+    @classmethod
+    def parse_model_output(cls, output: str) -> SummaryCommentReplySchema:
+        text = (output or "").strip()
+        if not text:
+            logger.warning("LLM returned empty summary")
+
+        return SummaryCommentReplySchema(text=text)

ai_review/services/review/internal/summary_reply/types.py

@@ -0,0 +1,8 @@
+from typing import Protocol
+
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
+
+
+class SummaryCommentReplyServiceProtocol(Protocol):
+    def parse_model_output(self, output: str) -> SummaryCommentReplySchema:
+        ...

ai_review/services/review/runner/context.py

@@ -0,0 +1,72 @@
+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.inline.types import InlineCommentServiceProtocol
+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 VCSClientProtocol
+
+logger = get_logger("CONTEXT_REVIEW_RUNNER")
+
+
+class ContextReviewRunner(ReviewRunnerProtocol):
+    def __init__(
+            self,
+            vcs: VCSClientProtocol,
+            git: GitServiceProtocol,
+            diff: DiffServiceProtocol,
+            cost: CostServiceProtocol,
+            prompt: PromptServiceProtocol,
+            review_policy: ReviewPolicyServiceProtocol,
+            inline_comment: InlineCommentServiceProtocol,
+            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.inline_comment = inline_comment
+        self.review_llm_gateway = review_llm_gateway
+        self.review_comment_gateway = review_comment_gateway
+
+    async def run(self) -> None:
+        await hook.emit_context_review_start()
+        if await self.review_comment_gateway.has_existing_inline_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 context review")
+            return
+
+        logger.info(f"Starting context inline 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_context_request(rendered_files, prompt_context)
+        prompt_system = self.prompt.build_system_context_request(prompt_context)
+        prompt_result = await self.review_llm_gateway.ask(prompt, prompt_system)
+
+        comments = self.inline_comment.parse_model_output(prompt_result).dedupe()
+        comments.root = self.review_policy.apply_for_context_comments(comments.root)
+        if not comments.root:
+            logger.info("No inline comments from context review")
+            return
+
+        logger.info(f"Posting {len(comments.root)} inline comments (context review)")
+        await self.review_comment_gateway.process_inline_comments(comments)
+        await hook.emit_context_review_complete(self.cost.aggregate())

ai_review/services/review/runner/inline.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 ReviewLLMGatewayProtocol, ReviewCommentGatewayProtocol
+from ai_review.services.review.internal.inline.types import InlineCommentServiceProtocol
+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
+
+logger = get_logger("INLINE_REVIEW_RUNNER")
+
+
+class InlineReviewRunner(ReviewRunnerProtocol):
+    def __init__(
+            self,
+            vcs: VCSClientProtocol,
+            git: GitServiceProtocol,
+            diff: DiffServiceProtocol,
+            cost: CostServiceProtocol,
+            prompt: PromptServiceProtocol,
+            review_policy: ReviewPolicyServiceProtocol,
+            inline_comment: InlineCommentServiceProtocol,
+            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.inline_comment = inline_comment
+        self.review_llm_gateway = review_llm_gateway
+        self.review_comment_gateway = review_comment_gateway
+
+    async def process_file(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,
+        )
+        prompt_context = build_prompt_context_from_review_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.review_llm_gateway.ask(prompt, prompt_system)
+
+        comments = self.inline_comment.parse_model_output(prompt_result).dedupe()
+        comments.root = self.review_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.review_comment_gateway.process_inline_comments(comments)
+
+    async def run(self) -> None:
+        await hook.emit_inline_review_start()
+        if await self.review_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.review_policy.apply_for_files(review_info.changed_files)
+        await bounded_gather([
+            self.process_file(changed_file, review_info)
+            for changed_file in changed_files
+        ])
+        await hook.emit_inline_review_complete(self.cost.aggregate())

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:
+        ...