xai-review 0.19.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

ai_review/services/artifacts/service.py

@@ -6,11 +6,12 @@ from ai_review.config import settings
 from ai_review.libs.logger import get_logger
 from ai_review.services.artifacts.schema import LLMArtifactSchema
 from ai_review.services.artifacts.tools import make_artifact_id
+from ai_review.services.artifacts.types import ArtifactsServiceProtocol
 
 logger = get_logger("ARTIFACTS_SERVICE")
 
 
-class ArtifactsService:
+class ArtifactsService(ArtifactsServiceProtocol):
     @classmethod
     async def save_llm_interaction(cls, prompt: str, prompt_system: str, response: str | None = None) -> str | None:
         if not settings.artifacts.llm_enabled:

ai_review/services/artifacts/types.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+from typing import Protocol
+
+
+class ArtifactsServiceProtocol(Protocol):
+    async def save_llm_interaction(
+            self,
+            prompt: str,
+            prompt_system: str,
+            response: str | None = None
+    ) -> str | None:
+        ...
+
+    async def save_artifact(
+            self,
+            file: Path,
+            content: str,
+            kind: str = "artifact"
+    ) -> Path | None:
+        ...

ai_review/services/cost/service.py

@@ -1,12 +1,13 @@
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
 from ai_review.services.cost.schema import CostReportSchema
+from ai_review.services.cost.types import CostServiceProtocol
 from ai_review.services.llm.types import ChatResultSchema
 
 logger = get_logger("COST_SERVICE")
 
 
-class CostService:
+class CostService(CostServiceProtocol):
     def __init__(self):
         self.pricing = settings.llm.load_pricing()
         self.reports: list[CostReportSchema] = []

ai_review/services/cost/types.py

@@ -0,0 +1,12 @@
+from typing import Protocol
+
+from ai_review.services.cost.schema import CostReportSchema
+from ai_review.services.llm.types import ChatResultSchema
+
+
+class CostServiceProtocol(Protocol):
+    def calculate(self, result: ChatResultSchema) -> CostReportSchema | None:
+        ...
+
+    def aggregate(self) -> CostReportSchema | None:
+        ...

ai_review/services/diff/service.py

@@ -16,12 +16,13 @@ from ai_review.services.diff.renderers import (
 )
 from ai_review.services.diff.schema import DiffFileSchema
 from ai_review.services.diff.tools import find_diff_file
+from ai_review.services.diff.types import DiffServiceProtocol
 from ai_review.services.git.types import GitServiceProtocol
 
 logger = get_logger("DIFF_SERVICE")
 
 
-class DiffService:
+class DiffService(DiffServiceProtocol):
     @classmethod
     def parse(cls, raw_diff: str) -> Diff:
         if not raw_diff.strip():

ai_review/services/diff/types.py

@@ -0,0 +1,28 @@
+from typing import Protocol
+
+from ai_review.libs.diff.models import Diff
+from ai_review.services.diff.schema import DiffFileSchema
+from ai_review.services.git.types import GitServiceProtocol
+
+
+class DiffServiceProtocol(Protocol):
+    def parse(self, raw_diff: str) -> Diff:
+        ...
+
+    def render_file(
+            self,
+            file: str,
+            raw_diff: str,
+            base_sha: str | None = None,
+            head_sha: str | None = None,
+    ) -> DiffFileSchema:
+        ...
+
+    def render_files(
+            self,
+            git: GitServiceProtocol,
+            files: list[str],
+            base_sha: str,
+            head_sha: str,
+    ) -> list[DiffFileSchema]:
+        ...

ai_review/services/hook/__init__.py

@@ -0,0 +1,5 @@
+from ai_review.services.hook.service import HookService
+
+hook = HookService()
+
+__all__ = ["hook"]

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