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

ai_review/clients/github/pr/client.py

@@ -11,21 +11,31 @@ from ai_review.clients.github.pr.schema.files import GitHubGetPRFilesResponseSch
 from ai_review.clients.github.pr.schema.pull_request import GitHubGetPRResponseSchema
 from ai_review.clients.github.pr.schema.reviews import GitHubGetPRReviewsResponseSchema
 from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.handlers import HTTPClientError, handle_http_error
+
+
+class GitHubPullRequestsHTTPClientError(HTTPClientError):
+    pass
 
 
 class GitHubPullRequestsHTTPClient(HTTPClient):
+    @handle_http_error(client="GitHubPullRequestsHTTPClient", exception=GitHubPullRequestsHTTPClientError)
     async def get_pull_request_api(self, owner: str, repo: str, pull_number: str) -> Response:
         return await self.get(f"/repos/{owner}/{repo}/pulls/{pull_number}")
 
+    @handle_http_error(client="GitHubPullRequestsHTTPClient", exception=GitHubPullRequestsHTTPClientError)
     async def get_files_api(self, owner: str, repo: str, pull_number: str) -> Response:
         return await self.get(f"/repos/{owner}/{repo}/pulls/{pull_number}/files")
 
+    @handle_http_error(client="GitHubPullRequestsHTTPClient", exception=GitHubPullRequestsHTTPClientError)
     async def get_issue_comments_api(self, owner: str, repo: str, issue_number: str) -> Response:
         return await self.get(f"/repos/{owner}/{repo}/issues/{issue_number}/comments")
 
+    @handle_http_error(client="GitHubPullRequestsHTTPClient", exception=GitHubPullRequestsHTTPClientError)
     async def get_review_comments_api(self, owner: str, repo: str, pull_number: str) -> Response:
         return await self.get(f"/repos/{owner}/{repo}/pulls/{pull_number}/comments")
 
+    @handle_http_error(client="GitHubPullRequestsHTTPClient", exception=GitHubPullRequestsHTTPClientError)
     async def create_review_comment_api(
             self,
             owner: str,
@@ -38,6 +48,7 @@ class GitHubPullRequestsHTTPClient(HTTPClient):
             json=request.model_dump(),
         )
 
+    @handle_http_error(client="GitHubPullRequestsHTTPClient", exception=GitHubPullRequestsHTTPClientError)
     async def create_issue_comment_api(
             self,
             owner: str,
@@ -50,6 +61,7 @@ class GitHubPullRequestsHTTPClient(HTTPClient):
             json=request.model_dump(),
         )
 
+    @handle_http_error(client="GitHubPullRequestsHTTPClient", exception=GitHubPullRequestsHTTPClientError)
     async def get_reviews_api(self, owner: str, repo: str, pull_number: str) -> Response:
         return await self.get(f"/repos/{owner}/{repo}/pulls/{pull_number}/reviews")
 
@@ -78,14 +90,8 @@ class GitHubPullRequestsHTTPClient(HTTPClient):
             owner: str,
             repo: str,
             pull_number: str,
-            body: str,
-            commit_id: str,
-            path: str,
-            line: int,
+            request: GitHubCreateReviewCommentRequestSchema
     ) -> GitHubCreateReviewCommentResponseSchema:
-        request = GitHubCreateReviewCommentRequestSchema(
-            body=body, commit_id=commit_id, path=path, line=line
-        )
         response = await self.create_review_comment_api(owner, repo, pull_number, request)
         return GitHubCreateReviewCommentResponseSchema.model_validate_json(response.text)
 

ai_review/clients/github/pr/schema/pull_request.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class GitHubUserSchema(BaseModel):
@@ -8,13 +8,13 @@ class GitHubUserSchema(BaseModel):
 
 class GitHubLabelSchema(BaseModel):
     id: int
-    name: str
+    name: str | None = None
 
 
 class GitHubBranchSchema(BaseModel):
     ref: str
     sha: str
-    label: str
+    label: str | None = None
 
 
 class GitHubGetPRResponseSchema(BaseModel):
@@ -23,8 +23,8 @@ class GitHubGetPRResponseSchema(BaseModel):
     title: str
     body: str | None = None
     user: GitHubUserSchema
-    labels: list[GitHubLabelSchema]
-    assignees: list[GitHubUserSchema] = []
-    requested_reviewers: list[GitHubUserSchema] = []
+    labels: list[GitHubLabelSchema] = Field(default_factory=list)
+    assignees: list[GitHubUserSchema] = Field(default_factory=list)
+    requested_reviewers: list[GitHubUserSchema] = Field(default_factory=list)
     base: GitHubBranchSchema
     head: GitHubBranchSchema

ai_review/clients/gitlab/mr/client.py

@@ -1,47 +1,56 @@
 from httpx import Response
 
 from ai_review.clients.gitlab.mr.schema.changes import GitLabGetMRChangesResponseSchema
-from ai_review.clients.gitlab.mr.schema.comments import (
-    GitLabGetMRCommentsResponseSchema,
-    GitLabCreateMRCommentRequestSchema,
-    GitLabCreateMRCommentResponseSchema,
-)
 from ai_review.clients.gitlab.mr.schema.discussions import (
     GitLabGetMRDiscussionsResponseSchema,
     GitLabCreateMRDiscussionRequestSchema,
     GitLabCreateMRDiscussionResponseSchema
 )
+from ai_review.clients.gitlab.mr.schema.notes import (
+    GitLabGetMRNotesResponseSchema,
+    GitLabCreateMRNoteRequestSchema,
+    GitLabCreateMRNoteResponseSchema,
+)
 from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.handlers import handle_http_error, HTTPClientError
 
 
-class GitLabMergeRequestsHTTPClient(HTTPClient):
+class GitLabMergeRequestsHTTPClientError(HTTPClientError):
+    pass
 
+
+class GitLabMergeRequestsHTTPClient(HTTPClient):
+    @handle_http_error(client="GitLabMergeRequestsHTTPClient", exception=GitLabMergeRequestsHTTPClientError)
     async def get_changes_api(self, project_id: str, merge_request_id: str) -> Response:
         return await self.get(
             f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/changes"
         )
 
-    async def get_comments_api(self, project_id: str, merge_request_id: str) -> Response:
+    @handle_http_error(client="GitLabMergeRequestsHTTPClient", exception=GitLabMergeRequestsHTTPClientError)
+    async def get_notes_api(self, project_id: str, merge_request_id: str) -> Response:
         return await self.get(
             f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/notes"
         )
 
+    @handle_http_error(client="GitLabMergeRequestsHTTPClient", exception=GitLabMergeRequestsHTTPClientError)
     async def get_discussions_api(self, project_id: str, merge_request_id: str) -> Response:
         return await self.get(
             f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/discussions"
         )
 
-    async def create_comment_api(
+    @handle_http_error(client="GitLabMergeRequestsHTTPClient", exception=GitLabMergeRequestsHTTPClientError)
+    async def create_note_api(
             self,
             project_id: str,
             merge_request_id: str,
-            request: GitLabCreateMRCommentRequestSchema,
+            request: GitLabCreateMRNoteRequestSchema,
     ) -> Response:
         return await self.post(
             f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/notes",
             json=request.model_dump(),
         )
 
+    @handle_http_error(client="GitLabMergeRequestsHTTPClient", exception=GitLabMergeRequestsHTTPClientError)
     async def create_discussion_api(
             self,
             project_id: str,
@@ -57,13 +66,13 @@ class GitLabMergeRequestsHTTPClient(HTTPClient):
         response = await self.get_changes_api(project_id, merge_request_id)
         return GitLabGetMRChangesResponseSchema.model_validate_json(response.text)
 
-    async def get_comments(
+    async def get_notes(
             self,
             project_id: str,
             merge_request_id: str
-    ) -> GitLabGetMRCommentsResponseSchema:
-        response = await self.get_comments_api(project_id, merge_request_id)
-        return GitLabGetMRCommentsResponseSchema.model_validate_json(response.text)
+    ) -> GitLabGetMRNotesResponseSchema:
+        response = await self.get_notes_api(project_id, merge_request_id)
+        return GitLabGetMRNotesResponseSchema.model_validate_json(response.text)
 
     async def get_discussions(
             self,
@@ -73,26 +82,26 @@ class GitLabMergeRequestsHTTPClient(HTTPClient):
         response = await self.get_discussions_api(project_id, merge_request_id)
         return GitLabGetMRDiscussionsResponseSchema.model_validate_json(response.text)
 
-    async def create_comment(
+    async def create_note(
             self,
-            comment: str,
+            body: str,
             project_id: str,
             merge_request_id: str,
-    ) -> GitLabCreateMRCommentResponseSchema:
-        request = GitLabCreateMRCommentRequestSchema(body=comment)
-        response = await self.create_comment_api(
+    ) -> GitLabCreateMRNoteResponseSchema:
+        request = GitLabCreateMRNoteRequestSchema(body=body)
+        response = await self.create_note_api(
             request=request,
             project_id=project_id,
             merge_request_id=merge_request_id
         )
-        return GitLabCreateMRCommentResponseSchema.model_validate_json(response.text)
+        return GitLabCreateMRNoteResponseSchema.model_validate_json(response.text)
 
     async def create_discussion(
             self,
             project_id: str,
             merge_request_id: str,
             request: GitLabCreateMRDiscussionRequestSchema
-    ):
+    ) -> GitLabCreateMRDiscussionResponseSchema:
         response = await self.create_discussion_api(
             request=request,
             project_id=project_id,

ai_review/clients/gitlab/mr/schema/changes.py

@@ -14,9 +14,9 @@ class GitLabDiffRefsSchema(BaseModel):
 
 
 class GitLabMRChangeSchema(BaseModel):
-    diff: str
-    old_path: str
-    new_path: str
+    diff: str | None = None
+    old_path: str | None = None
+    new_path: str | None = None
 
 
 class GitLabGetMRChangesResponseSchema(BaseModel):
@@ -24,12 +24,12 @@ class GitLabGetMRChangesResponseSchema(BaseModel):
     iid: int
     title: str
     author: GitLabUserSchema
-    labels: list[str] = []
+    labels: list[str] = Field(default_factory=list)
     changes: list[GitLabMRChangeSchema]
     assignees: list[GitLabUserSchema] = Field(default_factory=list)
     reviewers: list[GitLabUserSchema] = Field(default_factory=list)
     diff_refs: GitLabDiffRefsSchema
     project_id: int
-    description: str
+    description: str | None = None
     source_branch: str
     target_branch: str

ai_review/clients/gitlab/mr/schema/discussions.py

@@ -1,9 +1,6 @@
 from pydantic import BaseModel, RootModel
 
-
-class GitLabNoteSchema(BaseModel):
-    id: int
-    body: str
+from ai_review.clients.gitlab.mr.schema.notes import GitLabNoteSchema
 
 
 class GitLabDiscussionSchema(BaseModel):

ai_review/clients/gitlab/mr/schema/notes.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, RootModel
+
+
+class GitLabNoteSchema(BaseModel):
+    id: int
+    body: str
+
+
+class GitLabGetMRNotesResponseSchema(RootModel[list[GitLabNoteSchema]]):
+    root: list[GitLabNoteSchema]
+
+
+class GitLabCreateMRNoteRequestSchema(BaseModel):
+    body: str
+
+
+class GitLabCreateMRNoteResponseSchema(BaseModel):
+    id: int
+    body: str

ai_review/services/llm/factory.py

@@ -15,4 +15,4 @@ def get_llm_client() -> LLMClient:
         case LLMProvider.CLAUDE:
             return ClaudeLLMClient()
         case _:
-            raise ValueError(f"Unsupported provider: {settings.llm.provider}")
+            raise ValueError(f"Unsupported LLM provider: {settings.llm.provider}")

ai_review/services/prompt/adapter.py

@@ -1,25 +1,25 @@
 from ai_review.services.prompt.schema import PromptContextSchema
-from ai_review.services.vcs.types import MRInfoSchema
+from ai_review.services.vcs.types import ReviewInfoSchema
 
 
-def build_prompt_context_from_mr_info(mr: MRInfoSchema) -> PromptContextSchema:
+def build_prompt_context_from_mr_info(review: ReviewInfoSchema) -> PromptContextSchema:
     return PromptContextSchema(
-        merge_request_title=mr.title,
-        merge_request_description=mr.description,
+        review_title=review.title,
+        review_description=review.description,
 
-        merge_request_author_name=mr.author.name,
-        merge_request_author_username=mr.author.username,
+        review_author_name=review.author.name,
+        review_author_username=review.author.username,
 
-        merge_request_reviewers=[reviewer.name for reviewer in mr.reviewers],
-        merge_request_reviewers_usernames=[reviewer.username for reviewer in mr.reviewers],
-        merge_request_reviewer=mr.reviewers[0].name if mr.reviewers else "",
+        review_reviewers=[user.name for user in review.reviewers],
+        review_reviewers_usernames=[user.username for user in review.reviewers],
+        review_reviewer=review.reviewers[0].name if review.reviewers else "",
 
-        merge_request_assignees=[assignee.name for assignee in mr.assignees],
-        merge_request_assignees_usernames=[assignee.username for assignee in mr.assignees],
+        review_assignees=[user.name for user in review.assignees],
+        review_assignees_usernames=[user.username for user in review.assignees],
 
-        source_branch=mr.source_branch,
-        target_branch=mr.target_branch,
+        source_branch=review.source_branch.ref,
+        target_branch=review.target_branch.ref,
 
-        labels=mr.labels,
-        changed_files=mr.changed_files,
+        labels=review.labels,
+        changed_files=review.changed_files,
     )

ai_review/services/prompt/schema.py

@@ -5,18 +5,18 @@ from ai_review.libs.template.render import render_template
 
 
 class PromptContextSchema(BaseModel):
-    merge_request_title: str = ""
-    merge_request_description: str = ""
+    review_title: str = ""
+    review_description: str = ""
 
-    merge_request_author_name: str = ""
-    merge_request_author_username: str = ""
+    review_author_name: str = ""
+    review_author_username: str = ""
 
-    merge_request_reviewer: str = ""
-    merge_request_reviewers: list[str] = Field(default_factory=list)
-    merge_request_reviewers_usernames: list[str] = Field(default_factory=list)
+    review_reviewer: str = ""
+    review_reviewers: list[str] = Field(default_factory=list)
+    review_reviewers_usernames: list[str] = Field(default_factory=list)
 
-    merge_request_assignees: list[str] = Field(default_factory=list)
-    merge_request_assignees_usernames: list[str] = Field(default_factory=list)
+    review_assignees: list[str] = Field(default_factory=list)
+    review_assignees_usernames: list[str] = Field(default_factory=list)
 
     source_branch: str = ""
     target_branch: str = ""
@@ -27,18 +27,18 @@ class PromptContextSchema(BaseModel):
     @property
     def render_values(self) -> dict[str, str]:
         return {
-            "merge_request_title": self.merge_request_title,
-            "merge_request_description": self.merge_request_description,
+            "review_title": self.review_title,
+            "review_description": self.review_description,
 
-            "merge_request_author_name": self.merge_request_author_name,
-            "merge_request_author_username": self.merge_request_author_username,
+            "review_author_name": self.review_author_name,
+            "review_author_username": self.review_author_username,
 
-            "merge_request_reviewer": self.merge_request_reviewer,
-            "merge_request_reviewers": ", ".join(self.merge_request_reviewers),
-            "merge_request_reviewers_usernames": ", ".join(self.merge_request_reviewers_usernames),
+            "review_reviewer": self.review_reviewer,
+            "review_reviewers": ", ".join(self.review_reviewers),
+            "review_reviewers_usernames": ", ".join(self.review_reviewers_usernames),
 
-            "merge_request_assignees": ", ".join(self.merge_request_assignees),
-            "merge_request_assignees_usernames": ", ".join(self.merge_request_assignees_usernames),
+            "review_assignees": ", ".join(self.review_assignees),
+            "review_assignees_usernames": ", ".join(self.review_assignees_usernames),
 
             "source_branch": self.source_branch,
             "target_branch": self.target_branch,

ai_review/services/review/service.py

@@ -15,7 +15,7 @@ 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
 from ai_review.services.vcs.factory import get_vcs_client
-from ai_review.services.vcs.types import MRInfoSchema
+from ai_review.services.vcs.types import ReviewInfoSchema
 
 logger = get_logger("REVIEW_SERVICE")
 
@@ -52,37 +52,43 @@ class ReviewService:
             logger.exception(f"LLM request failed: {error}")
             raise
 
-    async def has_existing_inline_discussions(self) -> bool:
-        discussions = await self.vcs.get_discussions()
-        has_discussions = any(
-            settings.review.inline_tag in note.body
-            for discussion in discussions
-            for note in discussion.notes
+    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_discussions:
-            logger.info("Skipping inline review: AI inline discussions already exist")
+        if has_comments:
+            logger.info("Skipping inline review: AI inline comments already exist")
 
-        return has_discussions
+        return has_comments
 
     async def has_existing_summary_comments(self) -> bool:
-        comments = await self.vcs.get_comments()
-        has_comments = any(settings.review.summary_tag in comment.body for comment in comments)
+        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_discussions(self, flow: Literal["inline", "context"], comments: InlineCommentListSchema) -> None:
+    async def process_inline_comments(
+            self,
+            flow: Literal["inline", "context"],
+            comments: InlineCommentListSchema
+    ) -> None:
         results = await bounded_gather([
-            self.vcs.create_discussion(
+            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_comment(comment.fallback_body_with_tag)
+            self.vcs.create_general_comment(comment.fallback_body_with_tag)
             for comment, result in zip(comments.root, results)
             if isinstance(result, Exception)
         ]
@@ -90,19 +96,19 @@ class ReviewService:
             logger.warning(f"Falling back to {len(fallbacks)} general comments ({flow} review)")
             await bounded_gather(fallbacks)
 
-    async def process_file_inline(self, file: str, mr_info: MRInfoSchema) -> None:
-        raw_diff = self.git.get_diff_for_file(mr_info.base_sha, mr_info.head_sha, file)
+    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)
         if not raw_diff.strip():
             logger.debug(f"No diff for {file}, skipping")
             return
 
         rendered_file = self.diff.render_file(
             file=file,
-            base_sha=mr_info.base_sha,
-            head_sha=mr_info.head_sha,
+            base_sha=review_info.base_sha,
+            head_sha=review_info.head_sha,
             raw_diff=raw_diff,
         )
-        prompt_context = build_prompt_context_from_mr_info(mr_info)
+        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)
@@ -114,29 +120,27 @@ class ReviewService:
             return
 
         logger.info(f"Posting {len(comments.root)} inline comments to {file}")
-        await self.process_discussions(flow="inline", comments=comments)
+        await self.process_inline_comments(flow="inline", comments=comments)
 
     async def run_inline_review(self) -> None:
-        if await self.has_existing_inline_discussions():
+        if await self.has_existing_inline_comments():
             return
 
-        mr_info = await self.vcs.get_mr_info()
+        review_info = await self.vcs.get_review_info()
+        logger.info(f"Starting inline review: {len(review_info.changed_files)} files changed")
 
-        logger.info(f"Starting inline review: {len(mr_info.changed_files)} files changed")
-
-        changed_files = self.policy.apply_for_files(mr_info.changed_files)
+        changed_files = self.policy.apply_for_files(review_info.changed_files)
         await bounded_gather([
-            self.process_file_inline(changed_file, mr_info)
+            self.process_file_inline(changed_file, review_info)
             for changed_file in changed_files
         ])
 
     async def run_context_review(self) -> None:
-        if await self.has_existing_inline_discussions():
+        if await self.has_existing_inline_comments():
             return
 
-        mr_info = await self.vcs.get_mr_info()
-        changed_files = self.policy.apply_for_files(mr_info.changed_files)
-
+        review_info = await self.vcs.get_review_info()
+        changed_files = self.policy.apply_for_files(review_info.changed_files)
         if not changed_files:
             logger.info("No files to review for context review")
             return
@@ -146,10 +150,10 @@ class ReviewService:
         rendered_files = self.diff.render_files(
             git=self.git,
             files=changed_files,
-            base_sha=mr_info.base_sha,
-            head_sha=mr_info.head_sha,
+            base_sha=review_info.base_sha,
+            head_sha=review_info.head_sha,
         )
-        prompt_context = build_prompt_context_from_mr_info(mr_info)
+        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)
@@ -161,15 +165,14 @@ class ReviewService:
             return
 
         logger.info(f"Posting {len(comments.root)} inline comments (context review)")
-        await self.process_discussions(flow="context", comments=comments)
+        await self.process_inline_comments(flow="context", comments=comments)
 
     async def run_summary_review(self) -> None:
         if await self.has_existing_summary_comments():
             return
 
-        mr_info = await self.vcs.get_mr_info()
-        changed_files = self.policy.apply_for_files(mr_info.changed_files)
-
+        review_info = await self.vcs.get_review_info()
+        changed_files = self.policy.apply_for_files(review_info.changed_files)
         if not changed_files:
             logger.info("No files to review for summary")
             return
@@ -179,10 +182,10 @@ class ReviewService:
         rendered_files = self.diff.render_files(
             git=self.git,
             files=changed_files,
-            base_sha=mr_info.base_sha,
-            head_sha=mr_info.head_sha,
+            base_sha=review_info.base_sha,
+            head_sha=review_info.head_sha,
         )
-        prompt_context = build_prompt_context_from_mr_info(mr_info)
+        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)
@@ -193,7 +196,7 @@ class ReviewService:
             return
 
         logger.info(f"Posting summary review comment ({len(summary.text)} chars)")
-        await self.vcs.create_comment(summary.body_with_tag)
+        await self.vcs.create_general_comment(summary.body_with_tag)
 
     def report_total_cost(self):
         total_report = self.cost.aggregate()

ai_review/services/vcs/factory.py

@@ -12,4 +12,4 @@ def get_vcs_client() -> VCSClient:
         case VCSProvider.GITHUB:
             return GitHubVCSClient()
         case _:
-            raise ValueError(f"Unsupported provider: {settings.llm.provider}")
+            raise ValueError(f"Unsupported VCS provider: {settings.vcs.provider}")