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

ai_review/prompts/default_system_summary_reply.md

@@ -0,0 +1,13 @@
+You are an AI assistant participating in a code review discussion.
+
+Your role:
+
+- Act as a **technical reviewer**, not the code author.
+- Focus on clarity, correctness, and completeness of the code or proposal.
+- Keep your tone concise, professional, and factual (1–3 sentences).
+- Reply only to the latest message in the discussion thread.
+- When the user requests or implies an action (e.g. adding tests, refactoring, improving performance), provide a
+  **specific, actionable suggestion** or short code snippet that addresses it.
+- Avoid greetings, acknowledgements, or filler phrases.
+- Do not summarize past discussion history.
+- If no reply is needed, output exactly: `No reply`.

ai_review/services/artifacts/schema.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 
 from pydantic import BaseModel, Field
 
@@ -7,5 +7,5 @@ class LLMArtifactSchema(BaseModel):
     id: str
     prompt: str
     response: str | None = None
-    timestamp: str = Field(default_factory=datetime.utcnow().isoformat)
+    timestamp: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
     prompt_system: str

ai_review/services/hook/constants.py

@@ -15,6 +15,12 @@ class HookType(StrEnum):
     ON_SUMMARY_REVIEW_START = "ON_SUMMARY_REVIEW_START"
     ON_SUMMARY_REVIEW_COMPLETE = "ON_SUMMARY_REVIEW_COMPLETE"
 
+    ON_INLINE_REPLY_REVIEW_START = "ON_INLINE_REPLY_REVIEW_START"
+    ON_INLINE_REPLY_REVIEW_COMPLETE = "ON_INLINE_REPLY_REVIEW_COMPLETE"
+
+    ON_SUMMARY_REPLY_REVIEW_START = "ON_SUMMARY_REPLY_REVIEW_START"
+    ON_SUMMARY_REPLY_REVIEW_COMPLETE = "ON_SUMMARY_REPLY_REVIEW_COMPLETE"
+
     ON_INLINE_COMMENT_START = "ON_INLINE_COMMENT_START"
     ON_INLINE_COMMENT_ERROR = "ON_INLINE_COMMENT_ERROR"
     ON_INLINE_COMMENT_COMPLETE = "ON_INLINE_COMMENT_COMPLETE"
@@ -22,3 +28,11 @@ class HookType(StrEnum):
     ON_SUMMARY_COMMENT_START = "ON_SUMMARY_COMMENT_START"
     ON_SUMMARY_COMMENT_ERROR = "ON_SUMMARY_COMMENT_ERROR"
     ON_SUMMARY_COMMENT_COMPLETE = "ON_SUMMARY_COMMENT_COMPLETE"
+
+    ON_INLINE_COMMENT_REPLY_START = "ON_INLINE_COMMENT_REPLY_START"
+    ON_INLINE_COMMENT_REPLY_ERROR = "ON_INLINE_COMMENT_REPLY_ERROR"
+    ON_INLINE_COMMENT_REPLY_COMPLETE = "ON_INLINE_COMMENT_REPLY_COMPLETE"
+
+    ON_SUMMARY_COMMENT_REPLY_START = "ON_SUMMARY_COMMENT_REPLY_START"
+    ON_SUMMARY_COMMENT_REPLY_ERROR = "ON_SUMMARY_COMMENT_REPLY_ERROR"
+    ON_SUMMARY_COMMENT_REPLY_COMPLETE = "ON_SUMMARY_COMMENT_REPLY_COMPLETE"

ai_review/services/hook/service.py

@@ -19,16 +19,33 @@ from ai_review.services.hook.types import (
     # --- Summary Review ---
     SummaryReviewStartHookFunc,
     SummaryReviewCompleteHookFunc,
+    # --- Inline Reply Review ---
+    InlineReplyReviewStartHookFunc,
+    InlineReplyReviewCompleteHookFunc,
+    # --- Summary Reply Review ---
+    SummaryReplyReviewStartHookFunc,
+    SummaryReplyReviewCompleteHookFunc,
     # --- Inline Comment ---
     InlineCommentStartHookFunc,
     InlineCommentErrorHookFunc,
     InlineCommentCompleteHookFunc,
     # --- Summary Comment ---
     SummaryCommentStartHookFunc,
-    SummaryCommentCompleteHookFunc
+    SummaryCommentErrorHookFunc,
+    SummaryCommentCompleteHookFunc,
+    # --- Inline Reply Comment ---
+    InlineCommentReplyStartHookFunc,
+    InlineCommentReplyErrorHookFunc,
+    InlineCommentReplyCompleteHookFunc,
+    # --- Summary Reply Comment ---
+    SummaryCommentReplyStartHookFunc,
+    SummaryCommentReplyErrorHookFunc,
+    SummaryCommentReplyCompleteHookFunc
 )
-from ai_review.services.review.inline.schema import InlineCommentSchema
-from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.inline.schema import 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
 
 logger = get_logger("HOOK_SERVICE")
 
@@ -117,6 +134,36 @@ class HookService:
     async def emit_summary_review_complete(self, report: CostReportSchema | None):
         await self.emit(HookType.ON_SUMMARY_REVIEW_COMPLETE, report=report)
 
+    # --- Inline Reply Review ---
+    def on_inline_reply_review_start(self, func: InlineReplyReviewStartHookFunc):
+        self.inject_hook(HookType.ON_INLINE_REPLY_REVIEW_START, func)
+        return func
+
+    def on_inline_reply_review_complete(self, func: InlineReplyReviewCompleteHookFunc):
+        self.inject_hook(HookType.ON_INLINE_REPLY_REVIEW_COMPLETE, func)
+        return func
+
+    async def emit_inline_reply_review_start(self):
+        await self.emit(HookType.ON_INLINE_REPLY_REVIEW_START)
+
+    async def emit_inline_reply_review_complete(self, report: CostReportSchema | None):
+        await self.emit(HookType.ON_INLINE_REPLY_REVIEW_COMPLETE, report=report)
+
+    # --- Summary Reply Review ---
+    def on_summary_reply_review_start(self, func: SummaryReplyReviewStartHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_REPLY_REVIEW_START, func)
+        return func
+
+    def on_summary_reply_review_complete(self, func: SummaryReplyReviewCompleteHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_REPLY_REVIEW_COMPLETE, func)
+        return func
+
+    async def emit_summary_reply_review_start(self):
+        await self.emit(HookType.ON_SUMMARY_REPLY_REVIEW_START)
+
+    async def emit_summary_reply_review_complete(self, report: CostReportSchema | None):
+        await self.emit(HookType.ON_SUMMARY_REPLY_REVIEW_COMPLETE, report=report)
+
     # --- Inline Comment ---
     def on_inline_comment_start(self, func: InlineCommentStartHookFunc):
         self.inject_hook(HookType.ON_INLINE_COMMENT_START, func)
@@ -144,7 +191,7 @@ class HookService:
         self.inject_hook(HookType.ON_SUMMARY_COMMENT_START, func)
         return func
 
-    def on_summary_comment_error(self, func: InlineCommentErrorHookFunc):
+    def on_summary_comment_error(self, func: SummaryCommentErrorHookFunc):
         self.inject_hook(HookType.ON_SUMMARY_COMMENT_ERROR, func)
         return func
 
@@ -160,3 +207,47 @@ class HookService:
 
     async def emit_summary_comment_complete(self, comment: SummaryCommentSchema):
         await self.emit(HookType.ON_SUMMARY_COMMENT_COMPLETE, comment=comment)
+
+    # --- Inline Reply Comment ---
+    def on_inline_comment_reply_start(self, func: InlineCommentReplyStartHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_REPLY_START, func)
+        return func
+
+    def on_inline_comment_reply_error(self, func: InlineCommentReplyErrorHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_REPLY_ERROR, func)
+        return func
+
+    def on_inline_comment_reply_complete(self, func: InlineCommentReplyCompleteHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_REPLY_COMPLETE, func)
+        return func
+
+    async def emit_inline_comment_reply_start(self, comment: InlineCommentReplySchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_REPLY_START, comment=comment)
+
+    async def emit_inline_comment_reply_error(self, comment: InlineCommentReplySchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_REPLY_ERROR, comment=comment)
+
+    async def emit_inline_comment_reply_complete(self, comment: InlineCommentReplySchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_REPLY_COMPLETE, comment=comment)
+
+    # --- Inline Reply Comment ---
+    def on_summary_comment_reply_start(self, func: SummaryCommentReplyStartHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_REPLY_START, func)
+        return func
+
+    def on_summary_comment_reply_error(self, func: SummaryCommentReplyErrorHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_REPLY_ERROR, func)
+        return func
+
+    def on_summary_comment_reply_complete(self, func: SummaryCommentReplyCompleteHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_REPLY_COMPLETE, func)
+        return func
+
+    async def emit_summary_comment_reply_start(self, comment: SummaryCommentReplySchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_REPLY_START, comment=comment)
+
+    async def emit_summary_comment_reply_error(self, comment: SummaryCommentReplySchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_REPLY_ERROR, comment=comment)
+
+    async def emit_summary_comment_reply_complete(self, comment: SummaryCommentReplySchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_REPLY_COMPLETE, comment=comment)

ai_review/services/hook/types.py

@@ -1,8 +1,10 @@
 from typing import Callable, Awaitable
 
 from ai_review.services.cost.schema import CostReportSchema
-from ai_review.services.review.inline.schema import InlineCommentSchema
-from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.inline.schema import 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
 
 HookFunc = Callable[..., Awaitable[None]]
 
@@ -19,6 +21,12 @@ ContextReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[No
 SummaryReviewStartHookFunc = Callable[..., Awaitable[None]]
 SummaryReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
 
+InlineReplyReviewStartHookFunc = Callable[..., Awaitable[None]]
+InlineReplyReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
+
+SummaryReplyReviewStartHookFunc = Callable[..., Awaitable[None]]
+SummaryReplyReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
+
 InlineCommentStartHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
 InlineCommentErrorHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
 InlineCommentCompleteHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
@@ -26,3 +34,11 @@ InlineCommentCompleteHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
 SummaryCommentStartHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]
 SummaryCommentErrorHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]
 SummaryCommentCompleteHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]
+
+InlineCommentReplyStartHookFunc = Callable[[InlineCommentReplySchema], Awaitable[None]]
+InlineCommentReplyErrorHookFunc = Callable[[InlineCommentReplySchema], Awaitable[None]]
+InlineCommentReplyCompleteHookFunc = Callable[[InlineCommentReplySchema], Awaitable[None]]
+
+SummaryCommentReplyStartHookFunc = Callable[[SummaryCommentReplySchema], Awaitable[None]]
+SummaryCommentReplyErrorHookFunc = Callable[[SummaryCommentReplySchema], Awaitable[None]]
+SummaryCommentReplyCompleteHookFunc = Callable[[SummaryCommentReplySchema], Awaitable[None]]

ai_review/services/prompt/adapter.py

@@ -2,7 +2,7 @@ from ai_review.services.prompt.schema import PromptContextSchema
 from ai_review.services.vcs.types import ReviewInfoSchema
 
 
-def build_prompt_context_from_mr_info(review: ReviewInfoSchema) -> PromptContextSchema:
+def build_prompt_context_from_review_info(review: ReviewInfoSchema) -> PromptContextSchema:
     return PromptContextSchema(
         review_title=review.title,
         review_description=review.description,

ai_review/services/prompt/service.py

@@ -1,8 +1,9 @@
 from ai_review.config import settings
 from ai_review.services.diff.schema import DiffFileSchema
 from ai_review.services.prompt.schema import PromptContextSchema
-from ai_review.services.prompt.tools import normalize_prompt, format_file
+from ai_review.services.prompt.tools import normalize_prompt, format_file, format_thread, format_files
 from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.vcs.types import ReviewThreadSchema
 
 
 class PromptService(PromptServiceProtocol):
@@ -28,7 +29,7 @@ class PromptService(PromptServiceProtocol):
     @classmethod
     def build_summary_request(cls, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
         prompt = cls.prepare_prompt(settings.prompt.load_summary(), context)
-        changes = "\n\n".join(map(format_file, diffs))
+        changes = format_files(diffs)
         return (
             f"{prompt}\n\n"
             f"## Changes\n\n"
@@ -38,13 +39,50 @@ class PromptService(PromptServiceProtocol):
     @classmethod
     def build_context_request(cls, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
         prompt = cls.prepare_prompt(settings.prompt.load_context(), context)
-        changes = "\n\n".join(map(format_file, diffs))
+        changes = format_files(diffs)
         return (
             f"{prompt}\n\n"
             f"## Diff\n\n"
             f"{changes}\n"
         )
 
+    @classmethod
+    def build_inline_reply_request(
+            cls,
+            diff: DiffFileSchema,
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        prompt = cls.prepare_prompt(settings.prompt.load_inline_reply(), context)
+        conversation = format_thread(thread)
+
+        return (
+            f"{prompt}\n\n"
+            f"## Conversation\n\n"
+            f"{conversation}\n\n"
+            f"## Diff\n\n"
+            f"{format_file(diff)}"
+        )
+
+    @classmethod
+    def build_summary_reply_request(
+            cls,
+            diffs: list[DiffFileSchema],
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        prompt = cls.prepare_prompt(settings.prompt.load_summary_reply(), context)
+        changes = format_files(diffs)
+        conversation = format_thread(thread)
+
+        return (
+            f"{prompt}\n\n"
+            f"## Conversation\n\n"
+            f"{conversation}\n\n"
+            f"## Changes\n\n"
+            f"{changes}"
+        )
+
     @classmethod
     def build_system_inline_request(cls, context: PromptContextSchema) -> str:
         return cls.prepare_prompt(settings.prompt.load_system_inline(), context)
@@ -56,3 +94,11 @@ class PromptService(PromptServiceProtocol):
     @classmethod
     def build_system_summary_request(cls, context: PromptContextSchema) -> str:
         return cls.prepare_prompt(settings.prompt.load_system_summary(), context)
+
+    @classmethod
+    def build_system_inline_reply_request(cls, context: PromptContextSchema) -> str:
+        return cls.prepare_prompt(settings.prompt.load_system_inline_reply(), context)
+
+    @classmethod
+    def build_system_summary_reply_request(cls, context: PromptContextSchema) -> str:
+        return cls.prepare_prompt(settings.prompt.load_system_summary_reply(), context)

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