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

ai_review/services/prompt/tools.py

@@ -2,6 +2,7 @@ import re
 
 from ai_review.libs.logger import get_logger
 from ai_review.services.diff.schema import DiffFileSchema
+from ai_review.services.vcs.types import ReviewThreadSchema
 
 logger = get_logger("PROMPT_TOOLS")
 
@@ -10,6 +11,26 @@ def format_file(diff: DiffFileSchema) -> str:
     return f"# File: {diff.file}\n{diff.diff}\n"
 
 
+def format_files(diffs: list[DiffFileSchema]) -> str:
+    return "\n\n".join(map(format_file, diffs))
+
+
+def format_thread(thread: ReviewThreadSchema) -> str:
+    if not thread.comments:
+        return "No comments in thread."
+
+    lines: list[str] = []
+    for comment in thread.comments:
+        user = (comment.author.name or comment.author.username or "User").strip()
+        body = (comment.body or "").strip()
+        if not body:
+            continue
+
+        lines.append(f"- {user}: {body}")
+
+    return "\n\n".join(lines)
+
+
 def normalize_prompt(text: str) -> str:
     tails_stripped = [re.sub(r"[ \t]+$", "", line) for line in text.splitlines()]
     text = "\n".join(tails_stripped)

ai_review/services/prompt/types.py

@@ -2,6 +2,7 @@ from typing import Protocol
 
 from ai_review.services.diff.schema import DiffFileSchema
 from ai_review.services.prompt.schema import PromptContextSchema
+from ai_review.services.vcs.types import ReviewThreadSchema
 
 
 class PromptServiceProtocol(Protocol):
@@ -17,6 +18,22 @@ class PromptServiceProtocol(Protocol):
     def build_context_request(self, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
         ...
 
+    def build_inline_reply_request(
+            self,
+            diff: DiffFileSchema,
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        ...
+
+    def build_summary_reply_request(
+            self,
+            diffs: list[DiffFileSchema],
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        ...
+
     def build_system_inline_request(self, context: PromptContextSchema) -> str:
         ...
 
@@ -25,3 +42,9 @@ class PromptServiceProtocol(Protocol):
 
     def build_system_summary_request(self, context: PromptContextSchema) -> str:
         ...
+
+    def build_system_inline_reply_request(self, context: PromptContextSchema) -> str:
+        ...
+
+    def build_system_summary_reply_request(self, context: PromptContextSchema) -> str:
+        ...

ai_review/services/review/gateway/comment.py

@@ -2,17 +2,38 @@ from ai_review.config import settings
 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.inline.schema import InlineCommentListSchema, InlineCommentSchema
-from ai_review.services.review.summary.schema import SummaryCommentSchema
-from ai_review.services.vcs.types import VCSClientProtocol
+from ai_review.services.review.gateway.types import ReviewCommentGatewayProtocol
+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, ReviewThreadSchema
 
 logger = get_logger("REVIEW_COMMENT_GATEWAY")
 
 
-class ReviewCommentGateway:
+class ReviewCommentGateway(ReviewCommentGatewayProtocol):
     def __init__(self, vcs: VCSClientProtocol):
         self.vcs = vcs
 
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        threads = await self.vcs.get_inline_threads()
+        inline_threads = [
+            thread for thread in threads
+            if any(settings.review.inline_reply_tag in comment.body for comment in thread.comments)
+        ]
+        logger.info(f"Detected {len(inline_threads)}/{len(threads)} AI inline threads")
+        return inline_threads
+
+    async def get_summary_threads(self) -> list[ReviewThreadSchema]:
+        threads = await self.vcs.get_general_threads()
+        summary_threads = [
+            thread for thread in threads
+            if any(settings.review.summary_reply_tag in comment.body for comment in thread.comments)
+        ]
+        logger.info(f"Detected {len(summary_threads)}/{len(threads)} AI summary threads")
+        return summary_threads
+
     async def has_existing_inline_comments(self) -> bool:
         comments = await self.vcs.get_inline_comments()
         has_comments = any(
@@ -34,7 +55,25 @@ class ReviewCommentGateway:
 
         return has_comments
 
-    async def process_inline_comment(self, comment: InlineCommentSchema):
+    async def process_inline_reply(self, thread_id: str, reply: InlineCommentReplySchema) -> None:
+        try:
+            await hook.emit_inline_comment_reply_start(reply)
+            await self.vcs.create_inline_reply(thread_id, reply.body_with_tag)
+            await hook.emit_inline_comment_reply_complete(reply)
+        except Exception as error:
+            logger.exception(f"Failed to create inline reply for thread {thread_id}: {error}")
+            await hook.emit_inline_comment_reply_error(reply)
+
+    async def process_summary_reply(self, thread_id: str, reply: SummaryCommentReplySchema) -> None:
+        try:
+            await hook.emit_summary_comment_reply_start(reply)
+            await self.vcs.create_summary_reply(thread_id, reply.body_with_tag)
+            await hook.emit_summary_comment_reply_complete(reply)
+        except Exception as error:
+            logger.exception(f"Failed to create summary reply for thread {thread_id}: {error}")
+            await hook.emit_summary_comment_reply_error(reply)
+
+    async def process_inline_comment(self, comment: InlineCommentSchema) -> None:
         try:
             await hook.emit_inline_comment_start(comment)
             await self.vcs.create_inline_comment(
@@ -52,7 +91,7 @@ class ReviewCommentGateway:
             logger.warning(f"Falling back to general comment for {comment.file}:{comment.line}")
             await self.process_summary_comment(SummaryCommentSchema(text=comment.fallback_body))
 
-    async def process_summary_comment(self, comment: SummaryCommentSchema):
+    async def process_summary_comment(self, comment: SummaryCommentSchema) -> None:
         try:
             await hook.emit_summary_comment_start(comment)
             await self.vcs.create_general_comment(comment.body_with_tag)

ai_review/services/review/gateway/llm.py

@@ -3,11 +3,12 @@ from ai_review.services.artifacts.types import ArtifactsServiceProtocol
 from ai_review.services.cost.types import CostServiceProtocol
 from ai_review.services.hook import hook
 from ai_review.services.llm.types import LLMClientProtocol
+from ai_review.services.review.gateway.types import ReviewLLMGatewayProtocol
 
 logger = get_logger("REVIEW_LLM_GATEWAY")
 
 
-class ReviewLLMGateway:
+class ReviewLLMGateway(ReviewLLMGatewayProtocol):
     def __init__(
             self,
             llm: LLMClientProtocol,

ai_review/services/review/gateway/types.py

@@ -0,0 +1,50 @@
+from typing import Protocol
+
+from ai_review.services.artifacts.types import ArtifactsServiceProtocol
+from ai_review.services.cost.types import CostServiceProtocol
+from ai_review.services.llm.types import LLMClientProtocol
+from ai_review.services.review.internal.inline.schema import InlineCommentSchema, InlineCommentListSchema
+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, ReviewThreadSchema
+
+
+class ReviewLLMGatewayProtocol(Protocol):
+    llm: LLMClientProtocol
+    cost: CostServiceProtocol
+    artifacts: ArtifactsServiceProtocol
+
+    async def ask(self, prompt: str, prompt_system: str) -> str:
+        ...
+
+
+class ReviewCommentGatewayProtocol(Protocol):
+    vcs: VCSClientProtocol
+
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        ...
+
+    async def get_summary_threads(self) -> list[ReviewThreadSchema]:
+        ...
+
+    async def has_existing_inline_comments(self) -> bool:
+        ...
+
+    async def has_existing_summary_comments(self) -> bool:
+        ...
+
+    async def process_inline_reply(self, thread_id: str, reply: InlineCommentReplySchema) -> None:
+        ...
+
+    async def process_summary_reply(self, thread_id: str, reply: SummaryCommentReplySchema) -> None:
+        ...
+
+    async def process_inline_comment(self, comment: InlineCommentSchema) -> None:
+        ...
+
+    async def process_summary_comment(self, comment: SummaryCommentSchema) -> None:
+        ...
+
+    async def process_inline_comments(self, comments: InlineCommentListSchema) -> None:
+        ...

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

@@ -0,0 +1,40 @@
+import re
+
+from ai_review.libs.llm.output_json_parser import LLMOutputJSONParser
+from ai_review.libs.logger import get_logger
+from ai_review.services.review.internal.inline.schema import InlineCommentListSchema
+from ai_review.services.review.internal.inline.types import InlineCommentServiceProtocol
+
+logger = get_logger("INLINE_COMMENT_SERVICE")
+
+FIRST_JSON_ARRAY_RE = re.compile(r"\[[\s\S]*]", re.MULTILINE)
+
+
+class InlineCommentService(InlineCommentServiceProtocol):
+    def __init__(self):
+        self.parser = LLMOutputJSONParser(model=InlineCommentListSchema)
+
+    def parse_model_output(self, output: str) -> InlineCommentListSchema:
+        output = (output or "").strip()
+        if not output:
+            logger.warning("LLM returned empty string for inline review")
+            return InlineCommentListSchema(root=[])
+
+        if parsed := self.parser.parse_output(output):
+            return parsed
+
+        logger.warning("Failed to parse JSON, trying to extract first JSON array...")
+
+        if json_array_match := FIRST_JSON_ARRAY_RE.search(output):
+            extracted = json_array_match.group(0)
+            logger.debug(f"Extracted potential JSON array (len={len(extracted)})")
+
+            if parsed := self.parser.try_parse(extracted):
+                logger.info("Successfully parsed JSON after extracting array from output")
+                return parsed
+            else:
+                logger.error("Extracted JSON array is still invalid after sanitization")
+        else:
+            logger.error("No JSON array found in LLM output")
+
+        return InlineCommentListSchema(root=[])

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

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

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

@@ -0,0 +1,23 @@
+from pydantic import BaseModel, Field, field_validator
+
+from ai_review.config import settings
+
+
+class InlineCommentReplySchema(BaseModel):
+    message: str = Field(min_length=1)
+    suggestion: str | None = None
+
+    @field_validator("message")
+    def normalize_message(cls, value: str) -> str:
+        return value.strip()
+
+    @property
+    def body(self) -> str:
+        if self.suggestion:
+            return f"{self.message}\n\n```suggestion\n{self.suggestion}\n```"
+
+        return self.message
+
+    @property
+    def body_with_tag(self) -> str:
+        return f"{self.body}\n\n{settings.review.inline_reply_tag}"

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

@@ -0,0 +1,20 @@
+from ai_review.libs.llm.output_json_parser import LLMOutputJSONParser
+from ai_review.libs.logger import get_logger
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+from ai_review.services.review.internal.inline_reply.types import InlineCommentReplyServiceProtocol
+
+logger = get_logger("INLINE_COMMENT_REPLY_SERVICE")
+
+
+class InlineCommentReplyService(InlineCommentReplyServiceProtocol):
+    def __init__(self):
+        self.parser = LLMOutputJSONParser(model=InlineCommentReplySchema)
+
+    def parse_model_output(self, output: str) -> InlineCommentReplySchema | None:
+        logger.debug("Parsing LLM output for inline reply...")
+        parsed = self.parser.parse_output(output)
+        if parsed:
+            logger.debug("Inline reply parsed successfully")
+        else:
+            logger.warning("Inline reply parse failed or model returned empty JSON")
+        return parsed

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

@@ -0,0 +1,8 @@
+from typing import Protocol
+
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+
+
+class InlineCommentReplyServiceProtocol(Protocol):
+    def parse_model_output(self, output: str) -> InlineCommentReplySchema | None:
+        ...

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

@@ -2,11 +2,12 @@ import fnmatch
 
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
+from ai_review.services.review.internal.policy.types import ReviewPolicyServiceProtocol
 
 logger = get_logger("REVIEW_POLICY_SERVICE")
 
 
-class ReviewPolicyService:
+class ReviewPolicyService(ReviewPolicyServiceProtocol):
     @classmethod
     def should_review_file(cls, file: str) -> bool:
         review = settings.review

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())