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

ai_review/services/vcs/gitlab/client.py

@@ -1,15 +1,16 @@
 from ai_review.clients.gitlab.client import get_gitlab_http_client
-from ai_review.clients.gitlab.mr.schema.discussions import (
-    GitLabDiscussionPositionSchema,
-    GitLabCreateMRDiscussionRequestSchema,
-)
+from ai_review.clients.gitlab.mr.schema.discussions import GitLabCreateMRDiscussionRequestSchema
+from ai_review.clients.gitlab.mr.schema.position import GitLabPositionSchema
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.gitlab.adapter import get_user_from_gitlab_user, get_review_comment_from_gitlab_note
 from ai_review.services.vcs.types import (
     VCSClientProtocol,
     UserSchema,
+    ThreadKind,
     BranchRefSchema,
     ReviewInfoSchema,
+    ReviewThreadSchema,
     ReviewCommentSchema,
 )
 
@@ -21,16 +22,16 @@ class GitLabVCSClient(VCSClientProtocol):
         self.http_client = get_gitlab_http_client()
         self.project_id = settings.vcs.pipeline.project_id
         self.merge_request_id = settings.vcs.pipeline.merge_request_id
+        self.merge_request_ref = f"project_id={self.project_id} merge_request_id={self.merge_request_id}"
 
+    # --- Review info ---
     async def get_review_info(self) -> ReviewInfoSchema:
         try:
             response = await self.http_client.mr.get_changes(
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(
-                f"Fetched MR info for project_id={self.project_id} merge_request_id={self.merge_request_id}"
-            )
+            logger.info(f"Fetched MR info for {self.merge_request_ref}")
 
             return ReviewInfoSchema(
                 id=response.iid,
@@ -66,32 +67,29 @@ class GitLabVCSClient(VCSClientProtocol):
                 ],
             )
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch MR info for project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch MR info for {self.merge_request_ref}: {error}")
             return ReviewInfoSchema()
 
+    # --- Comments ---
     async def get_general_comments(self) -> list[ReviewCommentSchema]:
         try:
             response = await self.http_client.mr.get_notes(
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(
-                f"Fetched general comments for project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}"
-            )
+            logger.info(f"Fetched general comments for {self.merge_request_ref}")
 
             return [
-                ReviewCommentSchema(id=note.id, body=note.body or "")
+                ReviewCommentSchema(
+                    id=note.id,
+                    body=note.body or "",
+                    author=get_user_from_gitlab_user(note.author),
+                    thread_id=note.id
+                )
                 for note in response.root
             ]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch general comments project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch general comments {self.merge_request_ref}: {error}")
             return []
 
     async def get_inline_comments(self) -> list[ReviewCommentSchema]:
@@ -100,45 +98,33 @@ class GitLabVCSClient(VCSClientProtocol):
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(
-                f"Fetched inline discussions for project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}"
-            )
+            logger.info(f"Fetched inline discussions for {self.merge_request_ref}")
 
             return [
-                ReviewCommentSchema(id=note.id, body=note.body or "")
+                get_review_comment_from_gitlab_note(note, discussion)
                 for discussion in response.root
                 for note in discussion.notes
             ]
         except Exception as error:
-            logger.exception(
-                f"Failed to fetch inline discussions project_id={self.project_id} "
-                f"merge_request_id={self.merge_request_id}: {error}"
-            )
+            logger.exception(f"Failed to fetch inline discussions {self.merge_request_ref}: {error}")
             return []
 
     async def create_general_comment(self, message: str) -> None:
         try:
-            logger.info(
-                f"Posting general comment to merge_request_id={self.merge_request_id}: {message}"
-            )
+            logger.info(f"Posting general comment to {self.merge_request_ref}: {message}")
             await self.http_client.mr.create_note(
                 body=message,
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(f"Created general comment in merge_request_id={self.merge_request_id}")
+            logger.info(f"Created general comment in {self.merge_request_ref}")
         except Exception as error:
-            logger.exception(
-                f"Failed to create general comment in merge_request_id={self.merge_request_id}: {error}"
-            )
+            logger.exception(f"Failed to create general comment in {self.merge_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 merge_request_id={self.merge_request_id} at {file}:{line}: {message}"
-            )
+            logger.info(f"Posting inline comment in {self.merge_request_ref} at {file}:{line}: {message}")
 
             response = await self.http_client.mr.get_changes(
                 project_id=self.project_id,
@@ -147,7 +133,7 @@ class GitLabVCSClient(VCSClientProtocol):
 
             request = GitLabCreateMRDiscussionRequestSchema(
                 body=message,
-                position=GitLabDiscussionPositionSchema(
+                position=GitLabPositionSchema(
                     position_type="text",
                     base_sha=response.diff_refs.base_sha,
                     head_sha=response.diff_refs.head_sha,
@@ -161,12 +147,86 @@ class GitLabVCSClient(VCSClientProtocol):
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
+            logger.info(f"Created inline comment in {self.merge_request_ref} at {file}:{line}")
+        except Exception as error:
+            logger.exception(f"Failed to create inline comment in {self.merge_request_ref} at {file}:{line}: {error}")
+            raise
+
+    # --- Replies ---
+    async def create_inline_reply(self, thread_id: str | int, message: str) -> None:
+        try:
+            logger.info(f"Replying to discussion {thread_id=} in MR {self.merge_request_ref}")
+            await self.http_client.mr.create_discussion_reply(
+                project_id=self.project_id,
+                merge_request_id=self.merge_request_id,
+                discussion_id=str(thread_id),
+                body=message,
+            )
             logger.info(
-                f"Created inline comment in merge_request_id={self.merge_request_id} at {file}:{line}"
+                f"Created inline reply to discussion {thread_id=} in MR {self.merge_request_ref}"
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline reply to discussion {thread_id=} in MR {self.merge_request_ref}: {error}"
             )
+            raise
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        try:
+            logger.info(f"Replying to general comment {thread_id=} in MR {self.merge_request_ref}")
+            await self.create_general_comment(message)
         except Exception as error:
             logger.exception(
-                f"Failed to create inline comment in merge_request_id={self.merge_request_id} "
-                f"at {file}:{line}: {error}"
+                f"Failed to reply to general comment {thread_id=} in MR {self.merge_request_ref}: {error}"
             )
             raise
+
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            response = await self.http_client.mr.get_discussions(
+                project_id=self.project_id,
+                merge_request_id=self.merge_request_id,
+            )
+            logger.info(f"Fetched inline threads for MR {self.merge_request_ref}")
+
+            threads: list[ReviewThreadSchema] = []
+            for discussion in response.root:
+                if not discussion.notes:
+                    continue
+
+                position = discussion.position or (
+                    discussion.notes[0].position if discussion.notes else None
+                )
+
+                threads.append(
+                    ReviewThreadSchema(
+                        id=discussion.id,
+                        kind=ThreadKind.INLINE,
+                        file=position.new_path if position else None,
+                        line=position.new_line if position else None,
+                        comments=[
+                            get_review_comment_from_gitlab_note(note, discussion)
+                            for note in discussion.notes
+                        ],
+                    )
+                )
+
+            logger.info(f"Built {len(threads)} inline threads for MR {self.merge_request_ref}")
+            return threads
+        except Exception as error:
+            logger.exception(f"Failed to fetch inline threads for MR {self.merge_request_ref}: {error}")
+            return []
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        try:
+            comments = await self.get_general_comments()
+
+            threads = [
+                ReviewThreadSchema(id=comment.id, kind=ThreadKind.SUMMARY, comments=[comment])
+                for comment in comments
+            ]
+            logger.info(f"Built {len(threads)} general threads for MR {self.merge_request_ref}")
+            return threads
+        except Exception as error:
+            logger.exception(f"Failed to build general threads for MR {self.merge_request_ref}: {error}")
+            return []

ai_review/services/vcs/types.py

@@ -1,8 +1,14 @@
+from enum import StrEnum
 from typing import Protocol
 
 from pydantic import BaseModel, Field
 
 
+class ThreadKind(StrEnum):
+    INLINE = "INLINE"
+    SUMMARY = "SUMMARY"
+
+
 class UserSchema(BaseModel):
     id: str | int | None = None
     name: str = ""
@@ -35,10 +41,16 @@ class ReviewCommentSchema(BaseModel):
     body: str
     file: str | None = None
     line: int | None = None
+    author: UserSchema = Field(default_factory=UserSchema)
+    parent_id: str | int | None = None
+    thread_id: str | int | None = None
 
 
 class ReviewThreadSchema(BaseModel):
     id: str | int
+    kind: ThreadKind
+    file: str | None = None
+    line: int | None = None
     comments: list[ReviewCommentSchema]
 
 
@@ -48,9 +60,11 @@ class VCSClientProtocol(Protocol):
     Designed for code review automation: fetching review info, comments, and posting feedback.
     """
 
+    # --- Review info ---
     async def get_review_info(self) -> ReviewInfoSchema:
         """Fetch general information about the current review (PR/MR)."""
 
+    # --- Comments ---
     async def get_general_comments(self) -> list[ReviewCommentSchema]:
         """Fetch all top-level (non-inline) comments."""
 
@@ -62,3 +76,23 @@ class VCSClientProtocol(Protocol):
 
     async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         """Post a comment attached to a specific line in file."""
+
+    # --- Replies ---
+    async def create_inline_reply(self, thread_id: int | str, message: str) -> None:
+        """Reply to an existing inline comment thread."""
+
+    async def create_summary_reply(self, thread_id: int | str, message: str) -> None:
+        """Reply to a summary/general comment (flat if VCS doesn't support threads)."""
+
+    # --- Threads ---
+    async def get_inline_threads(self) -> list[ReviewThreadSchema]:
+        """
+        Fetch grouped inline comment threads.
+        If VCS doesn't support threads natively, group by file+line.
+        """
+
+    async def get_general_threads(self) -> list[ReviewThreadSchema]:
+        """
+        Fetch grouped general (summary-level) comment threads.
+        If VCS is flat (e.g. GitHub issues), each comment is a separate thread.
+        """

ai_review/tests/fixtures/clients/bitbucket.py

@@ -81,7 +81,7 @@ class FakeBitbucketPullRequestsHTTPClient(BitbucketPullRequestsHTTPClientProtoco
         return BitbucketGetPRFilesResponseSchema(
             size=2,
             page=1,
-            pagelen=100,
+            page_len=100,
             next=None,
             values=[
                 BitbucketPRFileSchema(
@@ -129,7 +129,7 @@ class FakeBitbucketPullRequestsHTTPClient(BitbucketPullRequestsHTTPClientProtoco
                     content=BitbucketCommentContentSchema(raw="Inline comment"),
                 ),
             ],
-            pagelen=100,
+            page_len=100,
         )
 
     async def create_comment(

ai_review/tests/fixtures/clients/github.py

@@ -3,8 +3,11 @@ from pydantic import HttpUrl, SecretStr
 
 from ai_review.clients.github.pr.schema.comments import (
     GitHubPRCommentSchema,
+    GitHubIssueCommentSchema,
     GitHubGetPRCommentsResponseSchema,
+    GitHubGetIssueCommentsResponseSchema,
     GitHubCreateIssueCommentResponseSchema,
+    GitHubCreateReviewReplyRequestSchema,
     GitHubCreateReviewCommentRequestSchema,
     GitHubCreateReviewCommentResponseSchema,
 )
@@ -30,7 +33,6 @@ class FakeGitHubPullRequestsHTTPClient(GitHubPullRequestsHTTPClientProtocol):
 
     async def get_pull_request(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRResponseSchema:
         self.calls.append(("get_pull_request", {"owner": owner, "repo": repo, "pull_number": pull_number}))
-
         return GitHubGetPRResponseSchema(
             id=1,
             number=1,
@@ -72,19 +74,31 @@ class FakeGitHubPullRequestsHTTPClient(GitHubPullRequestsHTTPClientProtocol):
             ]
         )
 
-    async def get_issue_comments(self, owner: str, repo: str, issue_number: str) -> GitHubGetPRCommentsResponseSchema:
+    async def get_issue_comments(
+            self,
+            owner: str,
+            repo: str,
+            issue_number: str
+    ) -> GitHubGetIssueCommentsResponseSchema:
         self.calls.append(("get_issue_comments", {"owner": owner, "repo": repo, "issue_number": issue_number}))
 
-        return GitHubGetPRCommentsResponseSchema(
+        return GitHubGetIssueCommentsResponseSchema(
             root=[
-                GitHubPRCommentSchema(id=1, body="General comment"),
-                GitHubPRCommentSchema(id=2, body="Another general comment"),
+                GitHubIssueCommentSchema(
+                    id=1,
+                    body="General comment",
+                    user=GitHubUserSchema(id=201, login="alice")
+                ),
+                GitHubIssueCommentSchema(
+                    id=2,
+                    body="Another general comment",
+                    user=GitHubUserSchema(id=202, login="bob"),
+                ),
             ]
         )
 
     async def get_review_comments(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRCommentsResponseSchema:
         self.calls.append(("get_review_comments", {"owner": owner, "repo": repo, "pull_number": pull_number}))
-
         return GitHubGetPRCommentsResponseSchema(
             root=[
                 GitHubPRCommentSchema(id=3, body="Inline comment", path="file.py", line=5),
@@ -102,6 +116,21 @@ class FakeGitHubPullRequestsHTTPClient(GitHubPullRequestsHTTPClientProtocol):
             ]
         )
 
+    async def create_review_reply(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            request: GitHubCreateReviewReplyRequestSchema,
+    ) -> GitHubCreateReviewCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_review_reply",
+                {"owner": owner, "repo": repo, "pull_number": pull_number, **request.model_dump()}
+            )
+        )
+        return GitHubCreateReviewCommentResponseSchema(id=12, body=request.body)
+
     async def create_review_comment(
             self,
             owner: str,

ai_review/tests/fixtures/clients/gitlab.py

@@ -12,12 +12,14 @@ from ai_review.clients.gitlab.mr.schema.discussions import (
     GitLabGetMRDiscussionsResponseSchema,
     GitLabCreateMRDiscussionRequestSchema,
     GitLabCreateMRDiscussionResponseSchema,
+    GitLabCreateMRDiscussionReplyResponseSchema,
 )
 from ai_review.clients.gitlab.mr.schema.notes import (
     GitLabNoteSchema,
     GitLabGetMRNotesResponseSchema,
     GitLabCreateMRNoteResponseSchema,
 )
+from ai_review.clients.gitlab.mr.schema.position import GitLabPositionSchema
 from ai_review.clients.gitlab.mr.types import GitLabMergeRequestsHTTPClientProtocol
 from ai_review.config import settings
 from ai_review.libs.config.vcs.base import GitLabVCSConfig
@@ -60,8 +62,16 @@ class FakeGitLabMergeRequestsHTTPClient(GitLabMergeRequestsHTTPClientProtocol):
         self.calls.append(("get_notes", {"project_id": project_id, "merge_request_id": merge_request_id}))
         return GitLabGetMRNotesResponseSchema(
             root=[
-                GitLabNoteSchema(id=1, body="General comment"),
-                GitLabNoteSchema(id=2, body="Another note"),
+                GitLabNoteSchema(
+                    id=1,
+                    body="General comment",
+                    author=GitLabUserSchema(id=301, name="Charlie", username="charlie"),
+                ),
+                GitLabNoteSchema(
+                    id=2,
+                    body="Another note",
+                    author=GitLabUserSchema(id=302, name="Diana", username="diana"),
+                ),
             ]
         )
 
@@ -72,10 +82,42 @@ class FakeGitLabMergeRequestsHTTPClient(GitLabMergeRequestsHTTPClientProtocol):
                 GitLabDiscussionSchema(
                     id="discussion-1",
                     notes=[
-                        GitLabNoteSchema(id=10, body="Inline comment A"),
-                        GitLabNoteSchema(id=11, body="Inline comment B"),
+                        GitLabNoteSchema(
+                            id=10,
+                            body="Inline comment A",
+                            position=GitLabPositionSchema(
+                                base_sha="abc123",
+                                head_sha="def456",
+                                start_sha="ghi789",
+                                new_path="src/app.py",
+                                new_line=12,
+                            ),
+                        ),
+                        GitLabNoteSchema(
+                            id=11,
+                            body="Inline comment B",
+                            position=GitLabPositionSchema(
+                                base_sha="abc123",
+                                head_sha="def456",
+                                start_sha="ghi789",
+                                new_path="src/app.py",
+                                new_line=14,
+                            ),
+                        ),
                     ],
-                )
+                    position=GitLabPositionSchema(
+                        base_sha="abc123",
+                        head_sha="def456",
+                        start_sha="ghi789",
+                        new_path="src/app.py",
+                        new_line=12,
+                    ),
+                ),
+                GitLabDiscussionSchema(
+                    id="discussion-2",
+                    notes=[GitLabNoteSchema(id=20, body="Outdated diff comment", position=None)],
+                    position=None,
+                ),
             ]
         )
 
@@ -100,7 +142,30 @@ class FakeGitLabMergeRequestsHTTPClient(GitLabMergeRequestsHTTPClientProtocol):
                 {"project_id": project_id, "merge_request_id": merge_request_id, "body": request.body}
             )
         )
-        return GitLabCreateMRDiscussionResponseSchema(id="discussion-new", body=request.body)
+        return GitLabCreateMRDiscussionResponseSchema(
+            id="discussion-new",
+            notes=[GitLabNoteSchema(id=1, body=request.body)]
+        )
+
+    async def create_discussion_reply(
+            self,
+            project_id: str,
+            merge_request_id: str,
+            discussion_id: str,
+            body: str,
+    ) -> GitLabCreateMRDiscussionReplyResponseSchema:
+        self.calls.append(
+            (
+                "create_discussion_reply",
+                {
+                    "project_id": project_id,
+                    "merge_request_id": merge_request_id,
+                    "discussion_id": discussion_id,
+                    "body": body,
+                },
+            )
+        )
+        return GitLabCreateMRDiscussionReplyResponseSchema(id=100, body=body)
 
 
 class FakeGitLabHTTPClient:

ai_review/tests/fixtures/libs/llm/output_json_parser.py

@@ -0,0 +1,13 @@
+import pytest
+from pydantic import BaseModel
+
+from ai_review.libs.llm.output_json_parser import LLMOutputJSONParser
+
+
+class DummyModel(BaseModel):
+    text: str
+
+
+@pytest.fixture
+def llm_output_json_parser() -> LLMOutputJSONParser:
+    return LLMOutputJSONParser(DummyModel)

ai_review/tests/fixtures/services/hook.py

@@ -0,0 +1,8 @@
+import pytest
+
+from ai_review.services.hook import HookService
+
+
+@pytest.fixture
+def hook_service() -> HookService:
+    return HookService()

ai_review/tests/fixtures/services/llm.py

@@ -13,11 +13,14 @@ class FakeLLMClient(LLMClientProtocol):
     async def chat(self, prompt: str, prompt_system: str) -> ChatResultSchema:
         self.calls.append(("chat", {"prompt": prompt, "prompt_system": prompt_system}))
 
-        return ChatResultSchema(
-            text=self.responses.get("text", "FAKE_RESPONSE"),
-            total_tokens=self.responses.get("total_tokens", 42),
-            prompt_tokens=self.responses.get("prompt_tokens", 21),
-            completion_tokens=self.responses.get("completion_tokens", 21),
+        return self.responses.get(
+            "chat",
+            ChatResultSchema(
+                text="FAKE_RESPONSE",
+                total_tokens=42,
+                prompt_tokens=21,
+                completion_tokens=21,
+            )
         )
 
 

ai_review/tests/fixtures/services/prompt.py

@@ -1,8 +1,10 @@
 import pytest
 
+from ai_review.libs.config.prompt import PromptConfig
 from ai_review.services.diff.schema import DiffFileSchema
 from ai_review.services.prompt.schema import PromptContextSchema
 from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.vcs.types import ReviewThreadSchema
 
 
 class FakePromptService(PromptServiceProtocol):
@@ -25,6 +27,24 @@ class FakePromptService(PromptServiceProtocol):
         self.calls.append(("build_context_request", {"diffs": diffs, "context": context}))
         return "CONTEXT_PROMPT"
 
+    def build_inline_reply_request(
+            self,
+            diff: DiffFileSchema,
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        self.calls.append(("build_inline_reply_request", {"diff": diff, "thread": thread, "context": context}))
+        return f"INLINE_REPLY_PROMPT_FOR_{diff.file}"
+
+    def build_summary_reply_request(
+            self,
+            diffs: list[DiffFileSchema],
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        self.calls.append(("build_summary_reply_request", {"diffs": diffs, "thread": thread, "context": context}))
+        return "SUMMARY_REPLY_PROMPT"
+
     def build_system_inline_request(self, context: PromptContextSchema) -> str:
         self.calls.append(("build_system_inline_request", {"context": context}))
         return "SYSTEM_INLINE_PROMPT"
@@ -37,7 +57,57 @@ class FakePromptService(PromptServiceProtocol):
         self.calls.append(("build_system_summary_request", {"context": context}))
         return "SYSTEM_SUMMARY_PROMPT"
 
+    def build_system_inline_reply_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_inline_reply_request", {"context": context}))
+        return "SYSTEM_INLINE_REPLY_PROMPT"
+
+    def build_system_summary_reply_request(self, context: PromptContextSchema) -> str:
+        self.calls.append(("build_system_summary_reply_request", {"context": context}))
+        return "SYSTEM_SUMMARY_REPLY_PROMPT"
+
 
 @pytest.fixture
 def fake_prompt_service() -> FakePromptService:
     return FakePromptService()
+
+
+@pytest.fixture
+def fake_prompts(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Patch methods of settings.prompt to return dummy values."""
+    monkeypatch.setattr(PromptConfig, "load_inline", lambda self: ["GLOBAL_INLINE", "INLINE_PROMPT"])
+    monkeypatch.setattr(PromptConfig, "load_context", lambda self: ["GLOBAL_CONTEXT", "CONTEXT_PROMPT"])
+    monkeypatch.setattr(PromptConfig, "load_summary", lambda self: ["GLOBAL_SUMMARY", "SUMMARY_PROMPT"])
+    monkeypatch.setattr(PromptConfig, "load_system_inline", lambda self: ["SYS_INLINE_A", "SYS_INLINE_B"])
+    monkeypatch.setattr(PromptConfig, "load_system_context", lambda self: ["SYS_CONTEXT_A", "SYS_CONTEXT_B"])
+    monkeypatch.setattr(PromptConfig, "load_system_summary", lambda self: ["SYS_SUMMARY_A", "SYS_SUMMARY_B"])
+    monkeypatch.setattr(PromptConfig, "load_inline_reply", lambda self: ["INLINE_REPLY_A", "INLINE_REPLY_B"])
+    monkeypatch.setattr(PromptConfig, "load_summary_reply", lambda self: ["SUMMARY_REPLY_A", "SUMMARY_REPLY_B"])
+    monkeypatch.setattr(
+        PromptConfig,
+        "load_system_inline_reply",
+        lambda self: ["SYS_INLINE_REPLY_A", "SYS_INLINE_REPLY_B"]
+    )
+    monkeypatch.setattr(
+        PromptConfig,
+        "load_system_summary_reply",
+        lambda self: ["SYS_SUMMARY_REPLY_A", "SYS_SUMMARY_REPLY_B"]
+    )
+
+
+@pytest.fixture
+def fake_prompt_context() -> PromptContextSchema:
+    """Builds a context object that reflects the new unified review schema."""
+    return PromptContextSchema(
+        review_title="Fix login bug",
+        review_description="Some description",
+        review_author_name="Nikita",
+        review_author_username="nikita.filonov",
+        review_reviewers=["Alice", "Bob"],
+        review_reviewers_usernames=["alice", "bob"],
+        review_assignees=["Charlie"],
+        review_assignees_usernames=["charlie"],
+        source_branch="feature/login-fix",
+        target_branch="main",
+        labels=["bug", "critical"],
+        changed_files=["foo.py", "bar.py"],
+    )