xai-review 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

ai_review/services/hook/constants.py

@@ -0,0 +1,24 @@
+from enum import StrEnum
+
+
+class HookType(StrEnum):
+    ON_CHAT_START = "ON_CHAT_START"
+    ON_CHAT_ERROR = "ON_CHAT_ERROR"
+    ON_CHAT_COMPLETE = "ON_CHAT_COMPLETE"
+
+    ON_INLINE_REVIEW_START = "ON_INLINE_REVIEW_START"
+    ON_INLINE_REVIEW_COMPLETE = "ON_INLINE_REVIEW_COMPLETE"
+
+    ON_CONTEXT_REVIEW_START = "ON_CONTEXT_REVIEW_START"
+    ON_CONTEXT_REVIEW_COMPLETE = "ON_CONTEXT_REVIEW_COMPLETE"
+
+    ON_SUMMARY_REVIEW_START = "ON_SUMMARY_REVIEW_START"
+    ON_SUMMARY_REVIEW_COMPLETE = "ON_SUMMARY_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"
+
+    ON_SUMMARY_COMMENT_START = "ON_SUMMARY_COMMENT_START"
+    ON_SUMMARY_COMMENT_ERROR = "ON_SUMMARY_COMMENT_ERROR"
+    ON_SUMMARY_COMMENT_COMPLETE = "ON_SUMMARY_COMMENT_COMPLETE"

ai_review/services/hook/service.py

@@ -0,0 +1,162 @@
+from collections import defaultdict
+from typing import Any
+
+from ai_review.libs.logger import get_logger
+from ai_review.services.cost.schema import CostReportSchema
+from ai_review.services.hook.constants import HookType
+from ai_review.services.hook.types import (
+    HookFunc,
+    # --- Chat ---
+    ChatStartHookFunc,
+    ChatErrorHookFunc,
+    ChatCompleteHookFunc,
+    # --- Inline Review ---
+    InlineReviewStartHookFunc,
+    InlineReviewCompleteHookFunc,
+    # --- Context Review ---
+    ContextReviewStartHookFunc,
+    ContextReviewCompleteHookFunc,
+    # --- Summary Review ---
+    SummaryReviewStartHookFunc,
+    SummaryReviewCompleteHookFunc,
+    # --- Inline Comment ---
+    InlineCommentStartHookFunc,
+    InlineCommentErrorHookFunc,
+    InlineCommentCompleteHookFunc,
+    # --- Summary Comment ---
+    SummaryCommentStartHookFunc,
+    SummaryCommentCompleteHookFunc
+)
+from ai_review.services.review.inline.schema import InlineCommentSchema
+from ai_review.services.review.summary.schema import SummaryCommentSchema
+
+logger = get_logger("HOOK_SERVICE")
+
+
+class HookService:
+    def __init__(self):
+        self.hooks: dict[HookType, list[HookFunc]] = defaultdict(list)
+
+    def inject_hook(self, name: HookType, func: HookFunc):
+        self.hooks[name].append(func)
+
+    async def emit(self, name: HookType, *args: Any, **kwargs: Any):
+        if not self.hooks.get(name):
+            return
+
+        for callback in self.hooks[name]:
+            try:
+                await callback(*args, **kwargs)
+            except Exception as error:
+                logger.exception(f"Error in {name} hook: {error}")
+
+    # --- Chat ---
+    def on_chat_start(self, func: ChatStartHookFunc):
+        self.inject_hook(HookType.ON_CHAT_START, func)
+        return func
+
+    def on_chat_error(self, func: ChatErrorHookFunc):
+        self.inject_hook(HookType.ON_CHAT_ERROR, func)
+        return func
+
+    def on_chat_complete(self, func: ChatCompleteHookFunc):
+        self.inject_hook(HookType.ON_CHAT_COMPLETE, func)
+        return func
+
+    async def emit_chat_start(self, prompt: str, prompt_system: str):
+        await self.emit(HookType.ON_CHAT_START, prompt=prompt, prompt_system=prompt_system)
+
+    async def emit_chat_error(self, prompt: str, prompt_system: str):
+        await self.emit(HookType.ON_CHAT_ERROR, prompt=prompt, prompt_system=prompt_system)
+
+    async def emit_chat_complete(self, result: str, report: CostReportSchema | None):
+        await self.emit(HookType.ON_CHAT_COMPLETE, result=result, report=report)
+
+    # --- Inline Review ---
+    def on_inline_review_start(self, func: InlineReviewStartHookFunc):
+        self.inject_hook(HookType.ON_INLINE_REVIEW_START, func)
+        return func
+
+    def on_inline_review_complete(self, func: InlineReviewCompleteHookFunc):
+        self.inject_hook(HookType.ON_INLINE_REVIEW_COMPLETE, func)
+        return func
+
+    async def emit_inline_review_start(self):
+        await self.emit(HookType.ON_INLINE_REVIEW_START)
+
+    async def emit_inline_review_complete(self, report: CostReportSchema | None):
+        await self.emit(HookType.ON_INLINE_REVIEW_COMPLETE, report=report)
+
+    # --- Context Review ---
+    def on_context_review_start(self, func: ContextReviewStartHookFunc):
+        self.inject_hook(HookType.ON_CONTEXT_REVIEW_START, func)
+        return func
+
+    def on_context_review_complete(self, func: ContextReviewCompleteHookFunc):
+        self.inject_hook(HookType.ON_CONTEXT_REVIEW_COMPLETE, func)
+        return func
+
+    async def emit_context_review_start(self):
+        await self.emit(HookType.ON_CONTEXT_REVIEW_START)
+
+    async def emit_context_review_complete(self, report: CostReportSchema | None):
+        await self.emit(HookType.ON_CONTEXT_REVIEW_COMPLETE, report=report)
+
+    # --- Summary Review ---
+    def on_summary_review_start(self, func: SummaryReviewStartHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_REVIEW_START, func)
+        return func
+
+    def on_summary_review_complete(self, func: SummaryReviewCompleteHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_REVIEW_COMPLETE, func)
+        return func
+
+    async def emit_summary_review_start(self):
+        await self.emit(HookType.ON_SUMMARY_REVIEW_START)
+
+    async def emit_summary_review_complete(self, report: CostReportSchema | None):
+        await self.emit(HookType.ON_SUMMARY_REVIEW_COMPLETE, report=report)
+
+    # --- Inline Comment ---
+    def on_inline_comment_start(self, func: InlineCommentStartHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_START, func)
+        return func
+
+    def on_inline_comment_error(self, func: InlineCommentErrorHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_ERROR, func)
+        return func
+
+    def on_inline_comment_complete(self, func: InlineCommentCompleteHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_COMPLETE, func)
+        return func
+
+    async def emit_inline_comment_start(self, comment: InlineCommentSchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_START, comment=comment)
+
+    async def emit_inline_comment_error(self, comment: InlineCommentSchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_ERROR, comment=comment)
+
+    async def emit_inline_comment_complete(self, comment: InlineCommentSchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_COMPLETE, comment=comment)
+
+    # --- Summary Comment ---
+    def on_summary_comment_start(self, func: SummaryCommentStartHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_START, func)
+        return func
+
+    def on_summary_comment_error(self, func: InlineCommentErrorHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_ERROR, func)
+        return func
+
+    def on_summary_comment_complete(self, func: SummaryCommentCompleteHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_COMPLETE, func)
+        return func
+
+    async def emit_summary_comment_start(self, comment: SummaryCommentSchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_START, comment=comment)
+
+    async def emit_summary_comment_error(self, comment: SummaryCommentSchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_ERROR, comment=comment)
+
+    async def emit_summary_comment_complete(self, comment: SummaryCommentSchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_COMPLETE, comment=comment)

ai_review/services/hook/types.py

@@ -0,0 +1,28 @@
+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
+
+HookFunc = Callable[..., Awaitable[None]]
+
+ChatStartHookFunc = Callable[[str, str], Awaitable[None]]
+ChatErrorHookFunc = Callable[[str, str], Awaitable[None]]
+ChatCompleteHookFunc = Callable[[str, CostReportSchema | None], Awaitable[None]]
+
+InlineReviewStartHookFunc = Callable[..., Awaitable[None]]
+InlineReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
+
+ContextReviewStartHookFunc = Callable[..., Awaitable[None]]
+ContextReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
+
+SummaryReviewStartHookFunc = Callable[..., Awaitable[None]]
+SummaryReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
+
+InlineCommentStartHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
+InlineCommentErrorHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
+InlineCommentCompleteHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
+
+SummaryCommentStartHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]
+SummaryCommentErrorHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]
+SummaryCommentCompleteHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]

ai_review/services/llm/claude/client.py

@@ -1,10 +1,10 @@
 from ai_review.clients.claude.client import get_claude_http_client
 from ai_review.clients.claude.schema import ClaudeChatRequestSchema, ClaudeMessageSchema
 from ai_review.config import settings
-from ai_review.services.llm.types import LLMClient, ChatResultSchema
+from ai_review.services.llm.types import LLMClientProtocol, ChatResultSchema
 
 
-class ClaudeLLMClient(LLMClient):
+class ClaudeLLMClient(LLMClientProtocol):
     def __init__(self):
         self.http_client = get_claude_http_client()
 

ai_review/services/llm/factory.py

@@ -3,10 +3,10 @@ from ai_review.libs.constants.llm_provider import LLMProvider
 from ai_review.services.llm.claude.client import ClaudeLLMClient
 from ai_review.services.llm.gemini.client import GeminiLLMClient
 from ai_review.services.llm.openai.client import OpenAILLMClient
-from ai_review.services.llm.types import LLMClient
+from ai_review.services.llm.types import LLMClientProtocol
 
 
-def get_llm_client() -> LLMClient:
+def get_llm_client() -> LLMClientProtocol:
     match settings.llm.provider:
         case LLMProvider.OPENAI:
             return OpenAILLMClient()

ai_review/services/llm/gemini/client.py

@@ -6,10 +6,10 @@ from ai_review.clients.gemini.schema import (
     GeminiGenerationConfigSchema,
 )
 from ai_review.config import settings
-from ai_review.services.llm.types import LLMClient, ChatResultSchema
+from ai_review.services.llm.types import LLMClientProtocol, ChatResultSchema
 
 
-class GeminiLLMClient(LLMClient):
+class GeminiLLMClient(LLMClientProtocol):
     def __init__(self):
         self.http_client = get_gemini_http_client()
 

ai_review/services/llm/openai/client.py

@@ -1,10 +1,10 @@
 from ai_review.clients.openai.client import get_openai_http_client
 from ai_review.clients.openai.schema import OpenAIChatRequestSchema, OpenAIMessageSchema
 from ai_review.config import settings
-from ai_review.services.llm.types import LLMClient, ChatResultSchema
+from ai_review.services.llm.types import LLMClientProtocol, ChatResultSchema
 
 
-class OpenAILLMClient(LLMClient):
+class OpenAILLMClient(LLMClientProtocol):
     def __init__(self):
         self.http_client = get_openai_http_client()
 

ai_review/services/llm/types.py

@@ -10,6 +10,6 @@ class ChatResultSchema(BaseModel):
     completion_tokens: int | None = None
 
 
-class LLMClient(Protocol):
+class LLMClientProtocol(Protocol):
     async def chat(self, prompt: str, prompt_system: str) -> ChatResultSchema:
         ...

ai_review/services/prompt/service.py

@@ -2,9 +2,10 @@ 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.types import PromptServiceProtocol
 
 
-class PromptService:
+class PromptService(PromptServiceProtocol):
     @classmethod
     def prepare_prompt(cls, prompts: list[str], context: PromptContextSchema) -> str:
         prompt = "\n\n".join(prompts)

ai_review/services/prompt/types.py

@@ -0,0 +1,27 @@
+from typing import Protocol
+
+from ai_review.services.diff.schema import DiffFileSchema
+from ai_review.services.prompt.schema import PromptContextSchema
+
+
+class PromptServiceProtocol(Protocol):
+    def prepare_prompt(self, prompts: list[str], context: PromptContextSchema) -> str:
+        ...
+
+    def build_inline_request(self, diff: DiffFileSchema, context: PromptContextSchema) -> str:
+        ...
+
+    def build_summary_request(self, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
+        ...
+
+    def build_context_request(self, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
+        ...
+
+    def build_system_inline_request(self, context: PromptContextSchema) -> str:
+        ...
+
+    def build_system_context_request(self, context: PromptContextSchema) -> str:
+        ...
+
+    def build_system_summary_request(self, context: PromptContextSchema) -> str:
+        ...

ai_review/services/review/gateway/comment.py

@@ -0,0 +1,65 @@
+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
+
+logger = get_logger("REVIEW_COMMENT_GATEWAY")
+
+
+class ReviewCommentGateway:
+    def __init__(self, vcs: VCSClientProtocol):
+        self.vcs = vcs
+
+    async def has_existing_inline_comments(self) -> bool:
+        comments = await self.vcs.get_inline_comments()
+        has_comments = any(
+            settings.review.inline_tag in comment.body
+            for comment in comments
+        )
+        if has_comments:
+            logger.info("Skipping inline review: AI inline comments already exist")
+
+        return has_comments
+
+    async def has_existing_summary_comments(self) -> bool:
+        comments = await self.vcs.get_general_comments()
+        has_comments = any(
+            settings.review.summary_tag in comment.body for comment in comments
+        )
+        if has_comments:
+            logger.info("Skipping summary review: AI summary comment already exists")
+
+        return has_comments
+
+    async def process_inline_comment(self, comment: InlineCommentSchema):
+        try:
+            await hook.emit_inline_comment_start(comment)
+            await self.vcs.create_inline_comment(
+                file=comment.file,
+                line=comment.line,
+                message=comment.body_with_tag,
+            )
+            await hook.emit_inline_comment_complete(comment)
+        except Exception as error:
+            logger.exception(
+                f"Failed to process inline comment for {comment.file}:{comment.line} — {error}"
+            )
+            await hook.emit_inline_comment_error(comment)
+
+            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):
+        try:
+            await hook.emit_summary_comment_start(comment)
+            await self.vcs.create_general_comment(comment.body_with_tag)
+            await hook.emit_summary_comment_complete(comment)
+        except Exception as error:
+            logger.exception(f"Failed to process summary comment: {comment} — {error}")
+            await hook.emit_summary_comment_error(comment)
+
+    async def process_inline_comments(self, comments: InlineCommentListSchema) -> None:
+        await bounded_gather([self.process_inline_comment(comment) for comment in comments.root])

ai_review/services/review/gateway/llm.py

@@ -0,0 +1,40 @@
+from ai_review.libs.logger import get_logger
+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
+
+logger = get_logger("REVIEW_LLM_GATEWAY")
+
+
+class ReviewLLMGateway:
+    def __init__(
+            self,
+            llm: LLMClientProtocol,
+            cost: CostServiceProtocol,
+            artifacts: ArtifactsServiceProtocol
+    ):
+        self.llm = llm
+        self.cost = cost
+        self.artifacts = artifacts
+
+    async def ask(self, prompt: str, prompt_system: str) -> str:
+        try:
+            await hook.emit_chat_start(prompt, prompt_system)
+            result = await self.llm.chat(prompt, prompt_system)
+            if not result.text:
+                logger.warning(
+                    f"LLM returned an empty response (prompt length={len(prompt)} chars)"
+                )
+
+            report = self.cost.calculate(result)
+            if report:
+                logger.info(report.pretty())
+
+            await hook.emit_chat_complete(result, report)
+            await self.artifacts.save_llm_interaction(prompt, prompt_system, result.text)
+
+            return result.text
+        except Exception as error:
+            logger.exception(f"LLM request failed: {error}")
+            await hook.emit_chat_error(prompt, prompt_system)

ai_review/services/review/inline/schema.py

@@ -38,8 +38,8 @@ class InlineCommentSchema(BaseModel):
         return f"{self.body}\n\n{settings.review.inline_tag}"
 
     @property
-    def fallback_body_with_tag(self) -> str:
-        return f"**{self.file}:{self.line}** — {self.message}\n\n{settings.review.inline_tag}"
+    def fallback_body(self) -> str:
+        return f"**{self.file}:{self.line}** — {self.message}"
 
 
 class InlineCommentListSchema(RootModel[list[InlineCommentSchema]]):

ai_review/services/review/inline/service.py

@@ -5,6 +5,7 @@ from pydantic import ValidationError
 from ai_review.libs.json import sanitize_json_string
 from ai_review.libs.logger import get_logger
 from ai_review.services.review.inline.schema import InlineCommentListSchema
+from ai_review.services.review.inline.types import InlineCommentServiceProtocol
 
 logger = get_logger("INLINE_COMMENT_SERVICE")
 
@@ -12,7 +13,7 @@ FIRST_JSON_ARRAY_RE = re.compile(r"\[[\s\S]*]", re.MULTILINE)
 CLEAN_JSON_BLOCK_RE = re.compile(r"```(?:json)?(.*?)```", re.DOTALL | re.IGNORECASE)
 
 
-class InlineCommentService:
+class InlineCommentService(InlineCommentServiceProtocol):
     @classmethod
     def try_parse_model_output(cls, raw: str) -> InlineCommentListSchema | None:
         try:

ai_review/services/review/inline/types.py

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

ai_review/services/review/service.py

@@ -1,16 +1,15 @@
-from typing import Literal
-
-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.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.inline.schema import InlineCommentListSchema
+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
@@ -33,68 +32,12 @@ class ReviewService:
         self.summary = SummaryCommentService()
         self.artifacts = ArtifactsService()
 
-    async def ask_llm(self, prompt: str, prompt_system: str) -> str:
-        try:
-            result = await self.llm.chat(prompt, prompt_system)
-            if not result.text:
-                logger.warning(
-                    f"LLM returned an empty response (prompt length={len(prompt)} chars)"
-                )
-
-            report = self.cost.calculate(result)
-            if report:
-                logger.info(report.pretty())
-
-            await self.artifacts.save_llm_interaction(prompt, prompt_system, result.text)
-
-            return result.text
-        except Exception as error:
-            logger.exception(f"LLM request failed: {error}")
-            raise
-
-    async def has_existing_inline_comments(self) -> bool:
-        comments = await self.vcs.get_inline_comments()
-        has_comments = any(
-            settings.review.inline_tag in comment.body
-            for comment in comments
-        )
-        if has_comments:
-            logger.info("Skipping inline review: AI inline comments already exist")
-
-        return has_comments
-
-    async def has_existing_summary_comments(self) -> bool:
-        comments = await self.vcs.get_general_comments()
-        has_comments = any(
-            settings.review.summary_tag in comment.body for comment in comments
+        self.llm_gateway = ReviewLLMGateway(
+            llm=self.llm,
+            cost=self.cost,
+            artifacts=self.artifacts
         )
-        if has_comments:
-            logger.info("Skipping summary review: AI summary comment already exists")
-
-        return has_comments
-
-    async def process_inline_comments(
-            self,
-            flow: Literal["inline", "context"],
-            comments: InlineCommentListSchema
-    ) -> None:
-        results = await bounded_gather([
-            self.vcs.create_inline_comment(
-                file=comment.file,
-                line=comment.line,
-                message=comment.body_with_tag
-            )
-            for comment in comments.root
-        ])
-
-        fallbacks = [
-            self.vcs.create_general_comment(comment.fallback_body_with_tag)
-            for comment, result in zip(comments.root, results)
-            if isinstance(result, Exception)
-        ]
-        if fallbacks:
-            logger.warning(f"Falling back to {len(fallbacks)} general comments ({flow} review)")
-            await bounded_gather(fallbacks)
+        self.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)
@@ -111,7 +54,7 @@ class ReviewService:
         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.ask_llm(prompt, prompt_system)
+        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)
@@ -120,10 +63,11 @@ class ReviewService:
             return
 
         logger.info(f"Posting {len(comments.root)} inline comments to {file}")
-        await self.process_inline_comments(flow="inline", comments=comments)
+        await self.comment_gateway.process_inline_comments(comments)
 
     async def run_inline_review(self) -> None:
-        if await self.has_existing_inline_comments():
+        await hook.emit_inline_review_start()
+        if await self.comment_gateway.has_existing_inline_comments():
             return
 
         review_info = await self.vcs.get_review_info()
@@ -134,9 +78,11 @@ class ReviewService:
             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:
-        if await self.has_existing_inline_comments():
+        await hook.emit_context_review_start()
+        if await self.comment_gateway.has_existing_inline_comments():
             return
 
         review_info = await self.vcs.get_review_info()
@@ -156,7 +102,7 @@ class ReviewService:
         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.ask_llm(prompt, prompt_system)
+        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)
@@ -165,10 +111,12 @@ class ReviewService:
             return
 
         logger.info(f"Posting {len(comments.root)} inline comments (context review)")
-        await self.process_inline_comments(flow="context", comments=comments)
+        await self.comment_gateway.process_inline_comments(comments)
+        await hook.emit_context_review_complete(self.cost.aggregate())
 
     async def run_summary_review(self) -> None:
-        if await self.has_existing_summary_comments():
+        await hook.emit_summary_review_start()
+        if await self.comment_gateway.has_existing_summary_comments():
             return
 
         review_info = await self.vcs.get_review_info()
@@ -188,7 +136,7 @@ class ReviewService:
         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.ask_llm(prompt, prompt_system)
+        prompt_result = await self.llm_gateway.ask(prompt, prompt_system)
 
         summary = self.summary.parse_model_output(prompt_result)
         if not summary.text.strip():
@@ -196,7 +144,8 @@ class ReviewService:
             return
 
         logger.info(f"Posting summary review comment ({len(summary.text)} chars)")
-        await self.vcs.create_general_comment(summary.body_with_tag)
+        await self.comment_gateway.process_summary_comment(summary)
+        await hook.emit_summary_review_complete(self.cost.aggregate())
 
     def report_total_cost(self):
         total_report = self.cost.aggregate()

ai_review/services/review/summary/service.py

@@ -1,10 +1,11 @@
 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
 
 logger = get_logger("SUMMARY_COMMENT_SERVICE")
 
 
-class SummaryCommentService:
+class SummaryCommentService(SummaryCommentServiceProtocol):
     @classmethod
     def parse_model_output(cls, output: str) -> SummaryCommentSchema:
         text = (output or "").strip()

ai_review/services/review/summary/types.py

@@ -0,0 +1,8 @@
+from typing import Protocol
+
+from ai_review.services.review.summary.schema import SummaryCommentSchema
+
+
+class SummaryCommentServiceProtocol(Protocol):
+    def parse_model_output(self, output: str) -> SummaryCommentSchema:
+        ...