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

ai_review/services/vcs/bitbucket/client.py

@@ -1,17 +1,20 @@
+from collections import defaultdict
+
 from ai_review.clients.bitbucket.client import get_bitbucket_http_client
 from ai_review.clients.bitbucket.pr.schema.comments import (
     BitbucketCommentInlineSchema,
     BitbucketCommentContentSchema,
-    BitbucketCreatePRCommentRequestSchema,
+    BitbucketCreatePRCommentRequestSchema, BitbucketParentSchema,
 )
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.bitbucket.adapter import get_review_comment_from_bitbucket_pr_comment
 from ai_review.services.vcs.types import (
     VCSClientProtocol,
     UserSchema,
     BranchRefSchema,
     ReviewInfoSchema,
-    ReviewCommentSchema,
+    ReviewCommentSchema, ReviewThreadSchema, ThreadKind,
 )
 
 logger = get_logger("BITBUCKET_VCS_CLIENT")
@@ -23,7 +26,9 @@ class BitbucketVCSClient(VCSClientProtocol):
         self.workspace = settings.vcs.pipeline.workspace
         self.repo_slug = settings.vcs.pipeline.repo_slug
         self.pull_request_id = settings.vcs.pipeline.pull_request_id
+        self.pull_request_ref = f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}"
 
+    # --- Review info ---
     async def get_review_info(self) -> ReviewInfoSchema:
         try:
             pr = await self.http_client.pr.get_pull_request(
@@ -37,7 +42,7 @@ class BitbucketVCSClient(VCSClientProtocol):
                 pull_request_id=self.pull_request_id,
             )
 
-            logger.info(f"Fetched PR info for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+            logger.info(f"Fetched PR info for {self.pull_request_ref}")
 
             return ReviewInfoSchema(
                 id=pr.id,
@@ -81,11 +86,10 @@ class BitbucketVCSClient(VCSClientProtocol):
                 ],
             )
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch PR info {self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch PR info {self.pull_request_ref}: {error}")
             return ReviewInfoSchema()
 
+    # --- Comments ---
     async def get_general_comments(self) -> list[ReviewCommentSchema]:
         try:
             response = await self.http_client.pr.get_comments(
@@ -93,18 +97,15 @@ class BitbucketVCSClient(VCSClientProtocol):
                 repo_slug=self.repo_slug,
                 pull_request_id=self.pull_request_id,
             )
-            logger.info(f"Fetched general comments for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+            logger.info(f"Fetched general comments for {self.pull_request_ref}")
 
             return [
-                ReviewCommentSchema(id=comment.id, body=comment.content.raw)
+                get_review_comment_from_bitbucket_pr_comment(comment)
                 for comment in response.values
                 if comment.inline is None
             ]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch general comments for "
-                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch general comments for {self.pull_request_ref}: {error}")
             return []
 
     async def get_inline_comments(self) -> list[ReviewCommentSchema]:
@@ -114,30 +115,20 @@ class BitbucketVCSClient(VCSClientProtocol):
                 repo_slug=self.repo_slug,
                 pull_request_id=self.pull_request_id,
             )
-            logger.info(f"Fetched inline comments for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+            logger.info(f"Fetched inline comments for {self.pull_request_ref}")
 
             return [
-                ReviewCommentSchema(
-                    id=comment.id,
-                    body=comment.content.raw,
-                    file=comment.inline.path,
-                    line=comment.inline.to_line,
-                )
+                get_review_comment_from_bitbucket_pr_comment(comment)
                 for comment in response.values
                 if comment.inline is not None
             ]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch inline comments for "
-                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch inline comments for {self.pull_request_ref}: {error}")
             return []
 
     async def create_general_comment(self, message: str) -> None:
         try:
-            logger.info(
-                f"Posting general comment to PR {self.workspace}/{self.repo_slug}#{self.pull_request_id}: {message}"
-            )
+            logger.info(f"Posting general comment to PR {self.pull_request_ref}: {message}")
             request = BitbucketCreatePRCommentRequestSchema(
                 content=BitbucketCommentContentSchema(raw=message)
             )
@@ -147,22 +138,14 @@ class BitbucketVCSClient(VCSClientProtocol):
                 pull_request_id=self.pull_request_id,
                 request=request,
             )
-            logger.info(
-                f"Created general comment in PR {self.workspace}/{self.repo_slug}#{self.pull_request_id}"
-            )
+            logger.info(f"Created general comment in PR {self.pull_request_ref}")
         except Exception as error:
-            logger.exception(
-                f"Failed to create general comment in PR "
-                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
-            )
+            logger.exception(f"Failed to create general comment in PR {self.pull_request_ref}: {error}")
             raise
 
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         try:
-            logger.info(
-                f"Posting inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
-                f"at {file}:{line}: {message}"
-            )
+            logger.info(f"Posting inline comment in {self.pull_request_ref} at {file}:{line}: {message}")
             request = BitbucketCreatePRCommentRequestSchema(
                 content=BitbucketCommentContentSchema(raw=message),
                 inline=BitbucketCommentInlineSchema(path=file, to_line=line),
@@ -173,13 +156,106 @@ class BitbucketVCSClient(VCSClientProtocol):
                 pull_request_id=self.pull_request_id,
                 request=request,
             )
-            logger.info(
-                f"Created inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
-                f"at {file}:{line}"
+            logger.info(f"Created inline comment in {self.pull_request_ref} at {file}:{line}")
+        except Exception as error:
+            logger.exception(f"Failed to create inline comment in {self.pull_request_ref} at {file}:{line}: {error}")
+            raise
+
+    # --- Replies ---
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        try:
+            logger.info(f"Replying to inline thread {thread_id=} in PR {self.pull_request_ref}")
+            request = BitbucketCreatePRCommentRequestSchema(
+                parent=BitbucketParentSchema(id=int(thread_id)),
+                content=BitbucketCommentContentSchema(raw=message),
+            )
+            await self.http_client.pr.create_comment(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+            logger.info(f"Created inline reply to thread {thread_id=} in PR {self.pull_request_ref}")
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline reply to thread {thread_id=} in PR {self.pull_request_ref}: {error}"
+            )
+            raise
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        try:
+            logger.info(f"Replying to summary thread {thread_id=} in PR {self.pull_request_ref}")
+            request = BitbucketCreatePRCommentRequestSchema(
+                content=BitbucketCommentContentSchema(raw=message),
+                parent=BitbucketParentSchema(id=int(thread_id)),
+            )
+            await self.http_client.pr.create_comment(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
             )
+            logger.info(f"Created summary reply to thread {thread_id=} in PR {self.pull_request_ref}")
         except Exception as error:
             logger.exception(
-                f"Failed to create inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
-                f"at {file}:{line}: {error}"
+                f"Failed to create summary reply to thread {thread_id=} in PR {self.pull_request_ref}: {error}"
             )
             raise
+
+    # --- Threads ---
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_inline_comments()
+
+            threads_by_id: dict[str | int, list[ReviewCommentSchema]] = defaultdict(list)
+            for comment in comments:
+                if not comment.file:
+                    continue
+
+                threads_by_id[comment.thread_id].append(comment)
+
+            logger.info(f"Built {len(threads_by_id)} inline threads for {self.pull_request_ref}")
+
+            threads: list[ReviewThreadSchema] = []
+            for thread_id, thread in threads_by_id.items():
+                file = thread[0].file
+                line = thread[0].line
+                if not file:
+                    continue
+
+                threads.append(
+                    ReviewThreadSchema(
+                        id=thread_id,
+                        kind=ThreadKind.INLINE,
+                        file=file,
+                        line=line,
+                        comments=sorted(thread, key=lambda t: int(t.id)),
+                    )
+                )
+
+            return threads
+        except Exception as error:
+            logger.exception(f"Failed to fetch inline threads for {self.pull_request_ref}: {error}")
+            return []
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_general_comments()
+
+            threads: dict[str | int, list[ReviewCommentSchema]] = defaultdict(list)
+            for comment in comments:
+                threads[comment.thread_id].append(comment)
+
+            logger.info(f"Built {len(threads)} general threads for {self.pull_request_ref}")
+
+            return [
+                ReviewThreadSchema(
+                    id=thread_id,
+                    kind=ThreadKind.SUMMARY,
+                    comments=sorted(thread, key=lambda c: int(c.id)),
+                )
+                for thread_id, thread in threads.items()
+            ]
+        except Exception as error:
+            logger.exception(f"Failed to fetch general threads for {self.pull_request_ref}: {error}")
+            return []

ai_review/services/vcs/github/adapter.py

@@ -0,0 +1,35 @@
+from ai_review.clients.github.pr.schema.comments import GitHubPRCommentSchema, GitHubIssueCommentSchema
+from ai_review.clients.github.pr.schema.user import GitHubUserSchema
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def get_user_from_github_user(user: GitHubUserSchema | None) -> UserSchema:
+    return UserSchema(
+        id=user.id if user else None,
+        name=user.login if user else "",
+        username=user.login if user else "",
+    )
+
+
+def get_review_comment_from_github_pr_comment(comment: GitHubPRCommentSchema) -> ReviewCommentSchema:
+    parent_id = comment.in_reply_to_id
+    thread_id = parent_id or comment.id
+
+    return ReviewCommentSchema(
+        id=comment.id,
+        body=comment.body or "",
+        file=comment.path,
+        line=comment.line,
+        author=get_user_from_github_user(comment.user),
+        parent_id=parent_id,
+        thread_id=thread_id,
+    )
+
+
+def get_review_comment_from_github_issue_comment(comment: GitHubIssueCommentSchema) -> ReviewCommentSchema:
+    return ReviewCommentSchema(
+        id=comment.id,
+        body=comment.body or "",
+        author=get_user_from_github_user(comment.user),
+        thread_id=comment.id
+    )

ai_review/services/vcs/github/client.py

@@ -1,12 +1,23 @@
+from collections import defaultdict
+
 from ai_review.clients.github.client import get_github_http_client
-from ai_review.clients.github.pr.schema.comments import GitHubCreateReviewCommentRequestSchema
+from ai_review.clients.github.pr.schema.comments import (
+    GitHubCreateReviewReplyRequestSchema,
+    GitHubCreateReviewCommentRequestSchema
+)
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.github.adapter import (
+    get_review_comment_from_github_pr_comment,
+    get_review_comment_from_github_issue_comment
+)
 from ai_review.services.vcs.types import (
     VCSClientProtocol,
+    ThreadKind,
     UserSchema,
     BranchRefSchema,
     ReviewInfoSchema,
+    ReviewThreadSchema,
     ReviewCommentSchema,
 )
 
@@ -19,7 +30,9 @@ class GitHubVCSClient(VCSClientProtocol):
         self.owner = settings.vcs.pipeline.owner
         self.repo = settings.vcs.pipeline.repo
         self.pull_number = settings.vcs.pipeline.pull_number
+        self.pull_request_ref = f"{self.owner}/{self.repo}#{self.pull_number}"
 
+    # --- Review info ---
     async def get_review_info(self) -> ReviewInfoSchema:
         try:
             pr = await self.http_client.pr.get_pull_request(
@@ -69,7 +82,7 @@ class GitHubVCSClient(VCSClientProtocol):
             )
             return ReviewInfoSchema()
 
-    # === GENERAL COMMENTS ===
+    # --- Comments ---
     async def get_general_comments(self) -> list[ReviewCommentSchema]:
         try:
             response = await self.http_client.pr.get_issue_comments(
@@ -77,18 +90,11 @@ class GitHubVCSClient(VCSClientProtocol):
                 repo=self.repo,
                 issue_number=self.pull_number,
             )
-            logger.info(
-                f"Fetched general comments for {self.owner}/{self.repo}#{self.pull_number}"
-            )
+            logger.info(f"Fetched general comments for {self.pull_request_ref}")
 
-            return [
-                ReviewCommentSchema(id=comment.id, body=comment.body or "")
-                for comment in response.root
-            ]
+            return [get_review_comment_from_github_issue_comment(comment) for comment in response.root]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch general comments for {self.owner}/{self.repo}#{self.pull_number}: {error}"
-            )
+            logger.exception(f"Failed to fetch general comments for {self.pull_request_ref}: {error}")
             return []
 
     async def get_inline_comments(self) -> list[ReviewCommentSchema]:
@@ -98,51 +104,30 @@ class GitHubVCSClient(VCSClientProtocol):
                 repo=self.repo,
                 pull_number=self.pull_number,
             )
-            logger.info(
-                f"Fetched inline comments for {self.owner}/{self.repo}#{self.pull_number}"
-            )
+            logger.info(f"Fetched inline comments for {self.pull_request_ref}")
 
-            return [
-                ReviewCommentSchema(
-                    id=comment.id,
-                    body=comment.body or "",
-                    file=comment.path,
-                    line=comment.line,
-                )
-                for comment in response.root
-            ]
+            return [get_review_comment_from_github_pr_comment(comment) for comment in response.root]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch inline comments for {self.owner}/{self.repo}#{self.pull_number}: {error}"
-            )
+            logger.exception(f"Failed to fetch inline comments for {self.pull_request_ref}: {error}")
             return []
 
     async def create_general_comment(self, message: str) -> None:
         try:
-            logger.info(
-                f"Posting general comment to PR {self.owner}/{self.repo}#{self.pull_number}: {message}"
-            )
+            logger.info(f"Posting general comment to PR {self.pull_request_ref}: {message}")
             await self.http_client.pr.create_issue_comment(
                 owner=self.owner,
                 repo=self.repo,
                 issue_number=self.pull_number,
                 body=message,
             )
-            logger.info(
-                f"Created general comment in PR {self.owner}/{self.repo}#{self.pull_number}"
-            )
+            logger.info(f"Created general comment in PR {self.pull_request_ref}")
         except Exception as error:
-            logger.exception(
-                f"Failed to create general comment in PR {self.owner}/{self.repo}#{self.pull_number}: {error}"
-            )
+            logger.exception(f"Failed to create general comment in PR {self.pull_request_ref}: {error}")
             raise
 
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         try:
-            logger.info(
-                f"Posting inline comment in {self.owner}/{self.repo}#{self.pull_number} "
-                f"at {file}:{line}: {message}"
-            )
+            logger.info(f"Posting inline comment in {self.pull_request_ref} at {file}:{line}: {message}")
 
             pr = await self.http_client.pr.get_pull_request(
                 owner=self.owner, repo=self.repo, pull_number=self.pull_number
@@ -160,12 +145,88 @@ class GitHubVCSClient(VCSClientProtocol):
                 pull_number=self.pull_number,
                 request=request,
             )
-            logger.info(
-                f"Created inline comment in {self.owner}/{self.repo}#{self.pull_number} at {file}:{line}"
+            logger.info(f"Created inline comment in {self.pull_request_ref} at {file}:{line}")
+        except Exception as error:
+            logger.exception(f"Failed to create inline comment in {self.pull_request_ref} at {file}:{line}: {error}")
+            raise
+
+    # --- Replies ---
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        try:
+            logger.info(f"Replying to inline comment {thread_id=} in PR {self.pull_request_ref}")
+            request = GitHubCreateReviewReplyRequestSchema(
+                body=message,
+                in_reply_to=thread_id
+            )
+            await self.http_client.pr.create_review_reply(
+                owner=self.owner,
+                repo=self.repo,
+                pull_number=self.pull_number,
+                request=request,
             )
+            logger.info(f"Created inline reply to comment {thread_id=} in PR {self.pull_request_ref}")
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline reply to comment {thread_id=} in {self.pull_request_ref}: {error}"
+            )
+            raise
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        """
+        GitHub does not support threaded replies for issue-level comments.
+        We post a new top-level comment instead.
+        """
+        try:
+            logger.info(f"Replying to general comment {thread_id=} in PR {self.pull_request_ref}")
+            await self.create_general_comment(message)
         except Exception as error:
             logger.exception(
-                f"Failed to create inline comment in {self.owner}/{self.repo}#{self.pull_number} "
-                f"at {file}:{line}: {error}"
+                f"Failed to create summary reply to comment {thread_id=} in {self.pull_request_ref}: {error}"
             )
             raise
+
+    # --- Threads ---
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            response = await self.http_client.pr.get_review_comments(
+                owner=self.owner,
+                repo=self.repo,
+                pull_number=self.pull_number,
+            )
+            comments = response.root
+            logger.info(f"Fetched inline comment threads for {self.pull_request_ref}")
+
+            threads: dict[str | int, list[ReviewCommentSchema]] = defaultdict(list)
+            for comment in comments:
+                review_comment = get_review_comment_from_github_pr_comment(comment)
+                threads[review_comment.thread_id].append(review_comment)
+
+            logger.info(f"Built {len(threads)} inline threads for {self.pull_request_ref}")
+
+            return [
+                ReviewThreadSchema(
+                    id=thread_id,
+                    kind=ThreadKind.INLINE,
+                    file=thread[0].file,
+                    line=thread[0].line,
+                    comments=sorted(thread, key=lambda t: int(t.id)),
+                )
+                for thread_id, thread in threads.items()
+            ]
+        except Exception as error:
+            logger.exception(f"Failed to fetch inline threads for {self.pull_request_ref}: {error}")
+            return []
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_general_comments()
+
+            threads = [
+                ReviewThreadSchema(id=comment.thread_id, kind=ThreadKind.SUMMARY, comments=[comment])
+                for comment in comments
+            ]
+            logger.info(f"Built {len(threads)} general threads for {self.pull_request_ref}")
+            return threads
+        except Exception as error:
+            logger.exception(f"Failed to build general threads for {self.pull_request_ref}: {error}")
+            return []

ai_review/services/vcs/gitlab/adapter.py

@@ -0,0 +1,28 @@
+from ai_review.clients.gitlab.mr.schema.discussions import GitLabDiscussionSchema
+from ai_review.clients.gitlab.mr.schema.notes import GitLabNoteSchema
+from ai_review.clients.gitlab.mr.schema.user import GitLabUserSchema
+from ai_review.services.vcs.types import ReviewCommentSchema, UserSchema
+
+
+def get_user_from_gitlab_user(user: GitLabUserSchema | None) -> UserSchema:
+    return UserSchema(
+        id=user.id if user else None,
+        name=user.name if user else "",
+        username=user.username if user else "",
+    )
+
+
+def get_review_comment_from_gitlab_note(
+        note: GitLabNoteSchema,
+        discussion: GitLabDiscussionSchema
+) -> ReviewCommentSchema:
+    position = note.position or discussion.position
+
+    return ReviewCommentSchema(
+        id=note.id,
+        body=note.body or "",
+        file=position.new_path if position else None,
+        line=position.new_line if position else None,
+        author=get_user_from_gitlab_user(note.author),
+        thread_id=discussion.id,
+    )