xai-review 0.11.0__tar.gz → 0.13.0__tar.gz

{xai_review-0.11.0 → xai_review-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xai-review
-Version: 0.11.0
+Version: 0.13.0
 Summary: AI-powered code review tool
 Author-email: Nikita Filonov <nikita.filonov@example.com>
 Maintainer-email: Nikita Filonov <nikita.filonov@example.com>

xai_review-0.13.0/ai_review/clients/github/client.py

@@ -0,0 +1,31 @@
+from httpx import AsyncClient, AsyncHTTPTransport
+
+from ai_review.clients.github.pr.client import GitHubPullRequestsHTTPClient
+from ai_review.config import settings
+from ai_review.libs.http.event_hooks.logger import LoggerEventHook
+from ai_review.libs.http.transports.retry import RetryTransport
+from ai_review.libs.logger import get_logger
+
+
+class GitHubHTTPClient:
+    def __init__(self, client: AsyncClient):
+        self.pr = GitHubPullRequestsHTTPClient(client)
+
+
+def get_github_http_client() -> GitHubHTTPClient:
+    logger = get_logger("GITHUB_HTTP_CLIENT")
+    logger_event_hook = LoggerEventHook(logger=logger)
+    retry_transport = RetryTransport(transport=AsyncHTTPTransport())
+
+    client = AsyncClient(
+        timeout=settings.llm.http_client.timeout,
+        headers={"Authorization": f"Bearer {settings.vcs.http_client.api_token_value}"},
+        base_url=settings.vcs.http_client.api_url_value,
+        transport=retry_transport,
+        event_hooks={
+            'request': [logger_event_hook.request],
+            'response': [logger_event_hook.response]
+        }
+    )
+
+    return GitHubHTTPClient(client=client)

xai_review-0.13.0/ai_review/clients/github/pr/client.py

@@ -0,0 +1,101 @@
+from httpx import Response
+
+from ai_review.clients.github.pr.schema.comments import (
+    GitHubGetPRCommentsResponseSchema,
+    GitHubCreateIssueCommentRequestSchema,
+    GitHubCreateIssueCommentResponseSchema,
+    GitHubCreateReviewCommentRequestSchema,
+    GitHubCreateReviewCommentResponseSchema
+)
+from ai_review.clients.github.pr.schema.files import GitHubGetPRFilesResponseSchema
+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
+
+
+class GitHubPullRequestsHTTPClient(HTTPClient):
+    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}")
+
+    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")
+
+    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")
+
+    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")
+
+    async def create_review_comment_api(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            request: GitHubCreateReviewCommentRequestSchema,
+    ) -> Response:
+        return await self.post(
+            f"/repos/{owner}/{repo}/pulls/{pull_number}/comments",
+            json=request.model_dump(),
+        )
+
+    async def create_issue_comment_api(
+            self,
+            owner: str,
+            repo: str,
+            issue_number: str,
+            request: GitHubCreateIssueCommentRequestSchema,
+    ) -> Response:
+        return await self.post(
+            f"/repos/{owner}/{repo}/issues/{issue_number}/comments",
+            json=request.model_dump(),
+        )
+
+    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")
+
+    async def get_pull_request(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRResponseSchema:
+        response = await self.get_pull_request_api(owner, repo, pull_number)
+        return GitHubGetPRResponseSchema.model_validate_json(response.text)
+
+    async def get_files(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRFilesResponseSchema:
+        response = await self.get_files_api(owner, repo, pull_number)
+        return GitHubGetPRFilesResponseSchema.model_validate_json(response.text)
+
+    async def get_issue_comments(self, owner: str, repo: str, issue_number: str) -> GitHubGetPRCommentsResponseSchema:
+        response = await self.get_issue_comments_api(owner, repo, issue_number)
+        return GitHubGetPRCommentsResponseSchema.model_validate_json(response.text)
+
+    async def get_review_comments(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRCommentsResponseSchema:
+        response = await self.get_review_comments_api(owner, repo, pull_number)
+        return GitHubGetPRCommentsResponseSchema.model_validate_json(response.text)
+
+    async def get_reviews(self, owner: str, repo: str, pull_number: str) -> GitHubGetPRReviewsResponseSchema:
+        response = await self.get_reviews_api(owner, repo, pull_number)
+        return GitHubGetPRReviewsResponseSchema.model_validate_json(response.text)
+
+    async def create_review_comment(
+            self,
+            owner: str,
+            repo: str,
+            pull_number: str,
+            body: str,
+            commit_id: str,
+            path: str,
+            line: int,
+    ) -> 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)
+
+    async def create_issue_comment(
+            self,
+            owner: str,
+            repo: str,
+            issue_number: str,
+            body: str,
+    ) -> GitHubCreateIssueCommentResponseSchema:
+        request = GitHubCreateIssueCommentRequestSchema(body=body)
+        response = await self.create_issue_comment_api(owner, repo, issue_number, request)
+        return GitHubCreateIssueCommentResponseSchema.model_validate_json(response.text)

xai_review-0.13.0/ai_review/clients/github/pr/schema/comments.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel, RootModel
+
+
+class GitHubPRCommentSchema(BaseModel):
+    id: int
+    body: str
+    path: str | None = None
+    line: int | None = None
+
+
+class GitHubGetPRCommentsResponseSchema(RootModel[list[GitHubPRCommentSchema]]):
+    root: list[GitHubPRCommentSchema]
+
+
+class GitHubCreateIssueCommentRequestSchema(BaseModel):
+    body: str
+
+
+class GitHubCreateIssueCommentResponseSchema(BaseModel):
+    id: int
+    body: str
+
+
+class GitHubCreateReviewCommentRequestSchema(BaseModel):
+    body: str
+    path: str
+    line: int
+    commit_id: str
+
+
+class GitHubCreateReviewCommentResponseSchema(BaseModel):
+    id: int
+    body: str

xai_review-0.13.0/ai_review/clients/github/pr/schema/files.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, RootModel
+
+
+class GitHubPRFileSchema(BaseModel):
+    sha: str
+    patch: str | None = None
+    status: str
+    filename: str
+
+
+class GitHubGetPRFilesResponseSchema(RootModel[list[GitHubPRFileSchema]]):
+    root: list[GitHubPRFileSchema]

xai_review-0.13.0/ai_review/clients/github/pr/schema/pull_request.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel
+
+
+class GitHubUserSchema(BaseModel):
+    id: int
+    login: str
+
+
+class GitHubLabelSchema(BaseModel):
+    id: int
+    name: str
+
+
+class GitHubBranchSchema(BaseModel):
+    ref: str
+    sha: str
+    label: str
+
+
+class GitHubGetPRResponseSchema(BaseModel):
+    id: int
+    number: int
+    title: str
+    body: str | None = None
+    user: GitHubUserSchema
+    labels: list[GitHubLabelSchema]
+    assignees: list[GitHubUserSchema] = []
+    requested_reviewers: list[GitHubUserSchema] = []
+    base: GitHubBranchSchema
+    head: GitHubBranchSchema

xai_review-0.13.0/ai_review/clients/github/pr/schema/reviews.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from pydantic import BaseModel, RootModel
+
+
+class GitHubPRReviewSchema(BaseModel):
+    id: int
+    body: Optional[str] = None
+    state: str
+
+
+class GitHubGetPRReviewsResponseSchema(RootModel[list[GitHubPRReviewSchema]]):
+    root: list[GitHubPRReviewSchema]

xai_review-0.13.0/ai_review/libs/config/github.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+from ai_review.libs.config.http import HTTPClientConfig
+
+
+class GitHubPipelineConfig(BaseModel):
+    repo: str
+    owner: str
+    pull_number: str
+
+
+class GitHubHTTPClientConfig(HTTPClientConfig):
+    pass

{xai_review-0.11.0 → xai_review-0.13.0}/ai_review/libs/config/prompt.py

@@ -8,6 +8,7 @@ from ai_review.libs.resources import load_resource
 
 class PromptConfig(BaseModel):
     context: dict[str, str] = Field(default_factory=dict)
+    normalize_prompts: bool = True
     context_placeholder: str = "<<{value}>>"
     inline_prompt_files: list[FilePath] | None = None
     context_prompt_files: list[FilePath] | None = None

{xai_review-0.11.0 → xai_review-0.13.0}/ai_review/libs/config/vcs.py

@@ -2,6 +2,7 @@ from typing import Annotated, Literal
 
 from pydantic import BaseModel, Field
 
+from ai_review.libs.config.github import GitHubPipelineConfig, GitHubHTTPClientConfig
 from ai_review.libs.config.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
 from ai_review.libs.constants.vcs_provider import VCSProvider
 
@@ -16,4 +17,10 @@ class GitLabVCSConfig(VCSConfigBase):
     http_client: GitLabHTTPClientConfig
 
 
-VCSConfig = Annotated[GitLabVCSConfig, Field(discriminator="provider")]
+class GitHubVCSConfig(VCSConfigBase):
+    provider: Literal[VCSProvider.GITHUB]
+    pipeline: GitHubPipelineConfig
+    http_client: GitHubHTTPClientConfig
+
+
+VCSConfig = Annotated[GitLabVCSConfig | GitHubVCSConfig, Field(discriminator="provider")]

{xai_review-0.11.0 → xai_review-0.13.0}/ai_review/services/prompt/service.py

@@ -1,56 +1,57 @@
 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
 
 
-def format_file(diff: DiffFileSchema) -> str:
-    return f"# File: {diff.file}\n{diff.diff}\n"
+class PromptService:
+    @classmethod
+    def prepare_prompt(cls, prompts: list[str], context: PromptContextSchema) -> str:
+        prompt = "\n\n".join(prompts)
+        prompt = context.apply_format(prompt)
 
+        if settings.prompt.normalize_prompts:
+            prompt = normalize_prompt(prompt)
+
+        return prompt
 
-class PromptService:
     @classmethod
     def build_inline_request(cls, diff: DiffFileSchema, context: PromptContextSchema) -> str:
-        inline_prompts = "\n\n".join(settings.prompt.load_inline())
-        inline_prompts = context.apply_format(inline_prompts)
+        prompt = cls.prepare_prompt(settings.prompt.load_inline(), context)
         return (
-            f"{inline_prompts}\n\n"
+            f"{prompt}\n\n"
             f"## Diff\n\n"
             f"{format_file(diff)}"
         )
 
     @classmethod
     def build_summary_request(cls, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
+        prompt = cls.prepare_prompt(settings.prompt.load_summary(), context)
         changes = "\n\n".join(map(format_file, diffs))
-        summary_prompts = "\n\n".join(settings.prompt.load_summary())
-        summary_prompts = context.apply_format(summary_prompts)
         return (
-            f"{summary_prompts}\n\n"
+            f"{prompt}\n\n"
             f"## Changes\n\n"
             f"{changes}\n"
         )
 
     @classmethod
     def build_context_request(cls, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
+        prompt = cls.prepare_prompt(settings.prompt.load_context(), context)
         changes = "\n\n".join(map(format_file, diffs))
-        inline_prompts = "\n\n".join(settings.prompt.load_context())
-        inline_prompts = context.apply_format(inline_prompts)
         return (
-            f"{inline_prompts}\n\n"
+            f"{prompt}\n\n"
             f"## Diff\n\n"
             f"{changes}\n"
         )
 
     @classmethod
     def build_system_inline_request(cls, context: PromptContextSchema) -> str:
-        prompt = "\n\n".join(settings.prompt.load_system_inline())
-        return context.apply_format(prompt)
+        return cls.prepare_prompt(settings.prompt.load_system_inline(), context)
 
     @classmethod
     def build_system_context_request(cls, context: PromptContextSchema) -> str:
-        prompt = "\n\n".join(settings.prompt.load_system_context())
-        return context.apply_format(prompt)
+        return cls.prepare_prompt(settings.prompt.load_system_context(), context)
 
     @classmethod
     def build_system_summary_request(cls, context: PromptContextSchema) -> str:
-        prompt = "\n\n".join(settings.prompt.load_system_summary())
-        return context.apply_format(prompt)
+        return cls.prepare_prompt(settings.prompt.load_system_summary(), context)

xai_review-0.13.0/ai_review/services/prompt/tools.py

@@ -0,0 +1,24 @@
+import re
+
+from ai_review.libs.logger import get_logger
+from ai_review.services.diff.schema import DiffFileSchema
+
+logger = get_logger("PROMPT_TOOLS")
+
+
+def format_file(diff: DiffFileSchema) -> str:
+    return f"# File: {diff.file}\n{diff.diff}\n"
+
+
+def normalize_prompt(text: str) -> str:
+    tails_stripped = [re.sub(r"[ \t]+$", "", line) for line in text.splitlines()]
+    text = "\n".join(tails_stripped)
+
+    text = re.sub(r"\n{3,}", "\n\n", text)
+
+    result = text.strip()
+    if len(text) > len(result):
+        logger.info(f"Prompt has been normalized from {len(text)} to {len(result)}")
+        return result
+
+    return text

{xai_review-0.11.0 → xai_review-0.13.0}/ai_review/services/vcs/factory.py

@@ -1,5 +1,6 @@
 from ai_review.config import settings
 from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.github.client import GitHubVCSClient
 from ai_review.services.vcs.gitlab.client import GitLabVCSClient
 from ai_review.services.vcs.types import VCSClient
 
@@ -8,5 +9,7 @@ def get_vcs_client() -> VCSClient:
     match settings.vcs.provider:
         case VCSProvider.GITLAB:
             return GitLabVCSClient()
+        case VCSProvider.GITHUB:
+            return GitHubVCSClient()
         case _:
             raise ValueError(f"Unsupported provider: {settings.llm.provider}")

xai_review-0.13.0/ai_review/services/vcs/github/client.py

@@ -0,0 +1,147 @@
+from ai_review.clients.github.client import get_github_http_client
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.types import (
+    VCSClient,
+    MRNoteSchema,
+    MRUserSchema,
+    MRInfoSchema,
+    MRCommentSchema,
+    MRDiscussionSchema,
+)
+
+logger = get_logger("GITHUB_VCS_CLIENT")
+
+
+class GitHubVCSClient(VCSClient):
+    def __init__(self):
+        self.http_client = get_github_http_client()
+        self.owner = settings.vcs.pipeline.owner
+        self.repo = settings.vcs.pipeline.repo
+        self.pull_number = settings.vcs.pipeline.pull_number
+
+    async def get_mr_info(self) -> MRInfoSchema:
+        try:
+            pr = await self.http_client.pr.get_pull_request(
+                owner=self.owner, repo=self.repo, pull_number=self.pull_number
+            )
+            files = await self.http_client.pr.get_files(
+                owner=self.owner, repo=self.repo, pull_number=self.pull_number
+            )
+
+            logger.info(
+                f"Fetched PR info for {self.owner}/{self.repo}#{self.pull_number}"
+            )
+
+            return MRInfoSchema(
+                title=pr.title,
+                author=MRUserSchema(
+                    name=pr.user.login,
+                    username=pr.user.login,
+                ),
+                labels=[label.name for label in pr.labels],
+                base_sha=pr.base.sha,
+                head_sha=pr.head.sha,
+                assignees=[
+                    MRUserSchema(name=user.login, username=user.login)
+                    for user in pr.assignees
+                ],
+                reviewers=[
+                    MRUserSchema(name=user.login, username=user.login)
+                    for user in pr.requested_reviewers
+                ],
+                description=pr.body or "",
+                source_branch=pr.head.ref,
+                target_branch=pr.base.ref,
+                changed_files=[file.filename for file in files.root],
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch PR info {self.owner}/{self.repo}#{self.pull_number}: {error}"
+            )
+            return MRInfoSchema()
+
+    async def get_comments(self) -> list[MRCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_issue_comments(
+                owner=self.owner,
+                repo=self.repo,
+                issue_number=self.pull_number,
+            )
+            logger.info(
+                f"Fetched issue comments for {self.owner}/{self.repo}#{self.pull_number}"
+            )
+
+            return [MRCommentSchema(id=comment.id, body=comment.body) for comment in response.root]
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch issue comments {self.owner}/{self.repo}#{self.pull_number}: {error}"
+            )
+            return []
+
+    async def get_discussions(self) -> list[MRDiscussionSchema]:
+        try:
+            response = await self.http_client.pr.get_review_comments(
+                owner=self.owner,
+                repo=self.repo,
+                pull_number=self.pull_number,
+            )
+            logger.info(
+                f"Fetched review comments for {self.owner}/{self.repo}#{self.pull_number}"
+            )
+
+            return [
+                MRDiscussionSchema(
+                    id=str(comment.id),
+                    notes=[MRNoteSchema(id=comment.id, body=comment.body or "")]
+                )
+                for comment in response.root
+            ]
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch review comments {self.owner}/{self.repo}#{self.pull_number}: {error}"
+            )
+            return []
+
+    async def create_comment(self, message: str) -> None:
+        try:
+            logger.info(
+                f"Posting general comment to PR {self.owner}/{self.repo}#{self.pull_number}: {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}"
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to create general comment in PR {self.owner}/{self.repo}#{self.pull_number}: {error}"
+            )
+
+    async def create_discussion(self, file: str, line: int, message: str) -> None:
+        try:
+            pr = await self.http_client.pr.get_pull_request(
+                owner=self.owner, repo=self.repo, pull_number=self.pull_number
+            )
+            commit_id = pr.head.sha
+
+            await self.http_client.pr.create_review_comment(
+                owner=self.owner,
+                repo=self.repo,
+                pull_number=self.pull_number,
+                body=message,
+                path=file,
+                line=line,
+                commit_id=commit_id,
+            )
+            logger.info(
+                f"Created inline comment in {self.owner}/{self.repo}#{self.pull_number} at {file}:{line}"
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline comment in {self.owner}/{self.repo}#{self.pull_number} at {file}:{line}: {error}"
+            )

xai_review-0.13.0/ai_review/tests/suites/clients/github/test_client.py

@@ -0,0 +1,36 @@
+import pytest
+from httpx import AsyncClient
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.github.client import get_github_http_client, GitHubHTTPClient
+from ai_review.clients.github.pr.client import GitHubPullRequestsHTTPClient
+from ai_review.config import settings
+from ai_review.libs.config.github import GitHubPipelineConfig, GitHubHTTPClientConfig
+from ai_review.libs.config.vcs import GitHubVCSConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+
+
+@pytest.fixture(autouse=True)
+def github_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = GitHubVCSConfig(
+        provider=VCSProvider.GITHUB,
+        pipeline=GitHubPipelineConfig(
+            repo="repo",
+            owner="owner",
+            pull_number="pull_number"
+        ),
+        http_client=GitHubHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://github.com"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "vcs", fake_config)
+
+
+def test_get_github_http_client_builds_ok():
+    github_http_client = get_github_http_client()
+
+    assert isinstance(github_http_client, GitHubHTTPClient)
+    assert isinstance(github_http_client.pr, GitHubPullRequestsHTTPClient)
+    assert isinstance(github_http_client.pr.client, AsyncClient)

{xai_review-0.11.0 → xai_review-0.13.0}/ai_review/tests/suites/services/prompt/test_service.py

@@ -1,5 +1,6 @@
 import pytest
 
+from ai_review.config import settings
 from ai_review.libs.config.prompt import PromptConfig
 from ai_review.services.diff.schema import DiffFileSchema
 from ai_review.services.prompt.schema import PromptContextSchema
@@ -134,3 +135,35 @@ def test_diff_placeholders_are_not_replaced(dummy_context: PromptContextSchema)
 
     assert "<<merge_request_title>>" in result
     assert "Fix login bug" not in result
+
+
+def test_prepare_prompt_basic_substitution(dummy_context: PromptContextSchema) -> None:
+    prompts = ["Hello", "MR title: <<merge_request_title>>"]
+    result = PromptService.prepare_prompt(prompts, dummy_context)
+    assert "Hello" in result
+    assert "MR title: Fix login bug" in result
+
+
+def test_prepare_prompt_applies_normalization(
+        monkeypatch: pytest.MonkeyPatch,
+        dummy_context: PromptContextSchema
+) -> None:
+    monkeypatch.setattr(settings.prompt, "normalize_prompts", True)
+    prompts = ["Line with space   ", "", "", "Next line"]
+    result = PromptService.prepare_prompt(prompts, dummy_context)
+
+    assert "Line with space" in result
+    assert "Next line" in result
+    assert "\n\n\n" not in result
+
+
+def test_prepare_prompt_skips_normalization(
+        monkeypatch: pytest.MonkeyPatch,
+        dummy_context: PromptContextSchema
+) -> None:
+    monkeypatch.setattr(settings.prompt, "normalize_prompts", False)
+    prompts = ["Line with space   ", "", "", "Next line"]
+    result = PromptService.prepare_prompt(prompts, dummy_context)
+
+    assert "Line with space   " in result
+    assert "\n\n\n" in result