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

ai_review/services/vcs/github/client.py

@@ -1,13 +1,13 @@
 from ai_review.clients.github.client import get_github_http_client
+from ai_review.clients.github.pr.schema.comments import GitHubCreateReviewCommentRequestSchema
 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,
+    UserSchema,
+    BranchRefSchema,
+    ReviewInfoSchema,
+    ReviewCommentSchema,
 )
 
 logger = get_logger("GITHUB_VCS_CLIENT")
@@ -20,7 +20,7 @@ class GitHubVCSClient(VCSClient):
         self.repo = settings.vcs.pipeline.repo
         self.pull_number = settings.vcs.pipeline.pull_number
 
-    async def get_mr_info(self) -> MRInfoSchema:
+    async def get_review_info(self) -> ReviewInfoSchema:
         try:
             pr = await self.http_client.pr.get_pull_request(
                 owner=self.owner, repo=self.repo, pull_number=self.pull_number
@@ -33,35 +33,44 @@ class GitHubVCSClient(VCSClient):
                 f"Fetched PR info for {self.owner}/{self.repo}#{self.pull_number}"
             )
 
-            return MRInfoSchema(
+            return ReviewInfoSchema(
+                id=pr.number,
                 title=pr.title,
-                author=MRUserSchema(
+                description=pr.body or "",
+                author=UserSchema(
+                    id=pr.user.id,
                     name=pr.user.login,
                     username=pr.user.login,
                 ),
-                labels=[label.name for label in pr.labels],
+                labels=[label.name for label in pr.labels if label.name],
                 base_sha=pr.base.sha,
                 head_sha=pr.head.sha,
                 assignees=[
-                    MRUserSchema(name=user.login, username=user.login)
+                    UserSchema(id=user.id, name=user.login, username=user.login)
                     for user in pr.assignees
                 ],
                 reviewers=[
-                    MRUserSchema(name=user.login, username=user.login)
+                    UserSchema(id=user.id, 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,
+                source_branch=BranchRefSchema(
+                    ref=pr.head.ref,
+                    sha=pr.head.sha,
+                ),
+                target_branch=BranchRefSchema(
+                    ref=pr.base.ref,
+                    sha=pr.base.sha,
+                ),
                 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()
+            return ReviewInfoSchema()
 
-    async def get_comments(self) -> list[MRCommentSchema]:
+    # === GENERAL COMMENTS ===
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
         try:
             response = await self.http_client.pr.get_issue_comments(
                 owner=self.owner,
@@ -69,17 +78,20 @@ class GitHubVCSClient(VCSClient):
                 issue_number=self.pull_number,
             )
             logger.info(
-                f"Fetched issue comments for {self.owner}/{self.repo}#{self.pull_number}"
+                f"Fetched general comments for {self.owner}/{self.repo}#{self.pull_number}"
             )
 
-            return [MRCommentSchema(id=comment.id, body=comment.body) for comment in response.root]
+            return [
+                ReviewCommentSchema(id=comment.id, body=comment.body or "")
+                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}"
+                f"Failed to fetch general comments for {self.owner}/{self.repo}#{self.pull_number}: {error}"
             )
             return []
 
-    async def get_discussions(self) -> list[MRDiscussionSchema]:
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
         try:
             response = await self.http_client.pr.get_review_comments(
                 owner=self.owner,
@@ -87,23 +99,25 @@ class GitHubVCSClient(VCSClient):
                 pull_number=self.pull_number,
             )
             logger.info(
-                f"Fetched review comments for {self.owner}/{self.repo}#{self.pull_number}"
+                f"Fetched inline comments for {self.owner}/{self.repo}#{self.pull_number}"
             )
 
             return [
-                MRDiscussionSchema(
-                    id=str(comment.id),
-                    notes=[MRNoteSchema(id=comment.id, body=comment.body or "")]
+                ReviewCommentSchema(
+                    id=comment.id,
+                    body=comment.body or "",
+                    file=comment.path,
+                    line=comment.line,
                 )
                 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}"
+                f"Failed to fetch inline comments for {self.owner}/{self.repo}#{self.pull_number}: {error}"
             )
             return []
 
-    async def create_comment(self, message: str) -> None:
+    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}"
@@ -122,30 +136,34 @@ class GitHubVCSClient(VCSClient):
                 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:
+    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} at {file}:{line}: {message}"
+                f"Posting inline comment in {self.owner}/{self.repo}#{self.pull_number} "
+                f"at {file}:{line}: {message}"
             )
 
             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
 
+            request = GitHubCreateReviewCommentRequestSchema(
+                body=message,
+                path=file,
+                line=line,
+                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,
+                request=request,
             )
             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}"
+                f"Failed to create inline comment in {self.owner}/{self.repo}#{self.pull_number} "
+                f"at {file}:{line}: {error}"
             )

ai_review/services/vcs/gitlab/client.py

@@ -1,17 +1,16 @@
 from ai_review.clients.gitlab.client import get_gitlab_http_client
 from ai_review.clients.gitlab.mr.schema.discussions import (
     GitLabDiscussionPositionSchema,
-    GitLabCreateMRDiscussionRequestSchema
+    GitLabCreateMRDiscussionRequestSchema,
 )
 from ai_review.config import settings
 from ai_review.libs.logger import get_logger
 from ai_review.services.vcs.types import (
     VCSClient,
-    MRUserSchema,
-    MRInfoSchema,
-    MRNoteSchema,
-    MRCommentSchema,
-    MRDiscussionSchema,
+    UserSchema,
+    BranchRefSchema,
+    ReviewInfoSchema,
+    ReviewCommentSchema,
 )
 
 logger = get_logger("GITLAB_VCS_CLIENT")
@@ -23,104 +22,121 @@ class GitLabVCSClient(VCSClient):
         self.project_id = settings.vcs.pipeline.project_id
         self.merge_request_id = settings.vcs.pipeline.merge_request_id
 
-    async def get_mr_info(self) -> MRInfoSchema:
+    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 project_id={self.project_id} merge_request_id={self.merge_request_id}"
+            )
 
-            return MRInfoSchema(
+            return ReviewInfoSchema(
+                id=response.iid,
                 title=response.title,
-                author=MRUserSchema(
+                description=response.description,
+                author=UserSchema(
                     name=response.author.name,
-                    username=response.author.username
+                    username=response.author.username,
+                    id=response.author.id,
                 ),
                 labels=response.labels,
                 base_sha=response.diff_refs.base_sha,
                 head_sha=response.diff_refs.head_sha,
                 start_sha=response.diff_refs.start_sha,
                 reviewers=[
-                    MRUserSchema(name=reviewer.name, username=reviewer.username)
-                    for reviewer in response.reviewers
+                    UserSchema(id=user.id, name=user.name, username=user.username)
+                    for user in response.reviewers
                 ],
                 assignees=[
-                    MRUserSchema(name=assignee.name, username=assignee.username)
-                    for assignee in response.assignees
+                    UserSchema(id=user.id, name=user.name, username=user.username)
+                    for user in response.assignees
+                ],
+                source_branch=BranchRefSchema(
+                    ref=response.source_branch,
+                    sha=response.diff_refs.head_sha,
+                ),
+                target_branch=BranchRefSchema(
+                    ref=response.target_branch,
+                    sha=response.diff_refs.base_sha,
+                ),
+                changed_files=[
+                    change.new_path for change in response.changes if change.new_path
                 ],
-                description=response.description,
-                source_branch=response.source_branch,
-                target_branch=response.target_branch,
-                changed_files=[change.new_path for change in response.changes if change.new_path],
             )
         except Exception as error:
             logger.exception(
-                f"Failed to fetch MR info project_id={self.project_id} "
+                f"Failed to fetch MR info for project_id={self.project_id} "
                 f"merge_request_id={self.merge_request_id}: {error}"
             )
-            return MRInfoSchema()
+            return ReviewInfoSchema()
 
-    async def get_comments(self) -> list[MRCommentSchema]:
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
         try:
-            response = await self.http_client.mr.get_comments(
+            response = await self.http_client.mr.get_notes(
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
             logger.info(
-                f"Fetched comments for project_id={self.project_id} merge_request_id={self.merge_request_id}"
+                f"Fetched general comments for project_id={self.project_id} "
+                f"merge_request_id={self.merge_request_id}"
             )
 
-            return [MRCommentSchema(id=comment.id, body=comment.body) for comment in response.root]
+            return [
+                ReviewCommentSchema(id=note.id, body=note.body or "")
+                for note in response.root
+            ]
         except Exception as error:
             logger.exception(
-                f"Failed to fetch comments project_id={self.project_id} "
+                f"Failed to fetch general comments project_id={self.project_id} "
                 f"merge_request_id={self.merge_request_id}: {error}"
             )
             return []
 
-    async def get_discussions(self) -> list[MRDiscussionSchema]:
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
         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 discussions for project_id={self.project_id} merge_request_id={self.merge_request_id}"
+                f"Fetched inline discussions for project_id={self.project_id} "
+                f"merge_request_id={self.merge_request_id}"
             )
 
             return [
-                MRDiscussionSchema(
-                    id=discussion.id,
-                    notes=[MRNoteSchema(id=note.id, body=note.body or "") for note in discussion.notes],
-                )
+                ReviewCommentSchema(id=note.id, body=note.body or "")
                 for discussion in response.root
+                for note in discussion.notes
             ]
         except Exception as error:
             logger.exception(
-                f"Failed to fetch discussions project_id={self.project_id} "
+                f"Failed to fetch inline discussions project_id={self.project_id} "
                 f"merge_request_id={self.merge_request_id}: {error}"
             )
             return []
 
-    async def create_comment(self, message: str) -> None:
+    async def create_general_comment(self, message: str) -> None:
         try:
             logger.info(
-                f"Posting comment to merge_request_id={self.merge_request_id}: {message}",
+                f"Posting general comment to merge_request_id={self.merge_request_id}: {message}"
             )
-            await self.http_client.mr.create_comment(
-                comment=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 comment in {self.merge_request_id=}")
+            logger.info(f"Created general comment in merge_request_id={self.merge_request_id}")
         except Exception as error:
-            logger.exception(f"Failed to create comment in merge_request_id={self.merge_request_id}: {error}")
+            logger.exception(
+                f"Failed to create general comment in merge_request_id={self.merge_request_id}: {error}"
+            )
 
-    async def create_discussion(self, file: str, line: int, message: str) -> None:
+    async def create_inline_comment(self, file: str, line: int, message: str) -> None:
         try:
             logger.info(
-                f"Posting discussion to merge_request_id={self.merge_request_id} at {file}:{line}: {message}"
+                f"Posting inline comment in merge_request_id={self.merge_request_id} at {file}:{line}: {message}"
             )
 
             response = await self.http_client.mr.get_changes(
@@ -137,16 +153,18 @@ class GitLabVCSClient(VCSClient):
                     start_sha=response.diff_refs.start_sha,
                     new_path=file,
                     new_line=line,
-                )
+                ),
             )
             await self.http_client.mr.create_discussion(
                 request=request,
                 project_id=self.project_id,
                 merge_request_id=self.merge_request_id,
             )
-            logger.info(f"Created discussion in merge_request_id={self.merge_request_id} at {file}:{line}")
+            logger.info(
+                f"Created inline comment in merge_request_id={self.merge_request_id} at {file}:{line}"
+            )
         except Exception as error:
             logger.exception(
-                f"Failed to create discussion in merge_request_id={self.merge_request_id} "
+                f"Failed to create inline comment in merge_request_id={self.merge_request_id} "
                 f"at {file}:{line}: {error}"
             )

ai_review/services/vcs/types.py

@@ -3,53 +3,62 @@ from typing import Protocol
 from pydantic import BaseModel, Field
 
 
-class MRUserSchema(BaseModel):
+class UserSchema(BaseModel):
+    id: str | int | None = None
     name: str = ""
     username: str = ""
 
 
-class MRInfoSchema(BaseModel):
+class BranchRefSchema(BaseModel):
+    ref: str = ""
+    sha: str = ""
+
+
+class ReviewInfoSchema(BaseModel):
+    id: str | int | None = None
     title: str = ""
-    author: MRUserSchema = Field(default_factory=MRUserSchema)
+    description: str = ""
+    author: UserSchema = Field(default_factory=UserSchema)
     labels: list[str] = Field(default_factory=list)
+    assignees: list[UserSchema] = Field(default_factory=list)
+    reviewers: list[UserSchema] = Field(default_factory=list)
+    source_branch: BranchRefSchema = Field(default_factory=BranchRefSchema)
+    target_branch: BranchRefSchema = Field(default_factory=BranchRefSchema)
+    changed_files: list[str] = Field(default_factory=list)
     base_sha: str = ""
     head_sha: str = ""
-    assignees: list[MRUserSchema] = Field(default_factory=list)
-    reviewers: list[MRUserSchema] = Field(default_factory=list)
     start_sha: str = ""
-    description: str = ""
-    source_branch: str = ""
-    target_branch: str = ""
-    changed_files: list[str] = Field(default_factory=list)
 
 
-class MRNoteSchema(BaseModel):
-    id: int | str
+class ReviewCommentSchema(BaseModel):
+    id: str | int
     body: str
+    file: str | None = None
+    line: int | None = None
 
 
-class MRDiscussionSchema(BaseModel):
-    id: str
-    notes: list[MRNoteSchema]
-
-
-class MRCommentSchema(BaseModel):
-    id: int | str
-    body: str
+class ReviewThreadSchema(BaseModel):
+    id: str | int
+    comments: list[ReviewCommentSchema]
 
 
 class VCSClient(Protocol):
-    async def get_mr_info(self) -> MRInfoSchema:
-        ...
+    """
+    Unified interface for version control system integrations (GitHub, GitLab, Bitbucket, etc.).
+    Designed for code review automation: fetching review info, comments, and posting feedback.
+    """
+
+    async def get_review_info(self) -> ReviewInfoSchema:
+        """Fetch general information about the current review (PR/MR)."""
 
-    async def get_comments(self) -> list[MRCommentSchema]:
-        ...
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
+        """Fetch all top-level (non-inline) comments."""
 
-    async def get_discussions(self) -> list[MRDiscussionSchema]:
-        ...
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
+        """Fetch inline (file + line attached) comments."""
 
-    async def create_comment(self, message: str) -> None:
-        ...
+    async def create_general_comment(self, message: str) -> None:
+        """Post a top-level comment."""
 
-    async def create_discussion(self, file: str, line: int, message: str) -> None:
-        ...
+    async def create_inline_comment(self, file: str, line: int, message: str) -> None:
+        """Post a comment attached to a specific line in file."""

ai_review/tests/suites/services/cost/test_schema.py

@@ -0,0 +1,124 @@
+import pytest
+
+from ai_review.services.cost.schema import CostReportSchema
+
+
+# ---------- tests: PERCENTAGE CALCULATIONS ----------
+
+def test_percent_calculations() -> None:
+    """
+    Should correctly calculate prompt and completion percent based on total cost.
+    """
+    report = CostReportSchema(
+        model="gpt-4",
+        prompt_tokens=1000,
+        completion_tokens=500,
+        input_cost=0.02,
+        output_cost=0.03,
+        total_cost=0.05,
+    )
+
+    assert pytest.approx(report.prompt_percent, 0.1) == 40.0
+    assert pytest.approx(report.completion_percent, 0.1) == 60.0
+
+
+def test_percent_zero_total_cost() -> None:
+    """
+    Should handle total_cost=0 without division errors and return 0%.
+    """
+    report = CostReportSchema(
+        model="gpt-4o-mini",
+        prompt_tokens=100,
+        completion_tokens=50,
+        input_cost=0.01,
+        output_cost=0.01,
+        total_cost=0.0,
+    )
+
+    assert report.prompt_percent == 0.0
+    assert report.completion_percent == 0.0
+
+
+# ---------- tests: PRETTY LINES ----------
+
+def test_pretty_prompt_line_format() -> None:
+    """
+    Should render a formatted line for prompt tokens and cost.
+    """
+    report = CostReportSchema(
+        model="gpt-4",
+        prompt_tokens=1234,
+        completion_tokens=0,
+        input_cost=0.012345,
+        output_cost=0.0,
+        total_cost=0.012345,
+    )
+    out = report.pretty_prompt_line
+
+    assert "- Prompt tokens:" in out
+    assert "1234" in out
+    assert "USD" in out
+    assert "(" in out
+    assert ")" in out
+
+
+def test_pretty_completion_line_format() -> None:
+    """
+    Should render a formatted line for completion tokens and cost.
+    """
+    report = CostReportSchema(
+        model="gpt-4",
+        prompt_tokens=0,
+        completion_tokens=567,
+        input_cost=0.0,
+        output_cost=0.06789,
+        total_cost=0.06789,
+    )
+    out = report.pretty_completion_line
+
+    assert "- Completion tokens:" in out
+    assert "567" in out
+    assert "USD" in out
+
+
+def test_pretty_total_line_format() -> None:
+    """
+    Should render a formatted total cost line.
+    """
+    report = CostReportSchema(
+        model="gpt-4",
+        prompt_tokens=0,
+        completion_tokens=0,
+        input_cost=0.0,
+        output_cost=0.0,
+        total_cost=1.234567,
+    )
+    out = report.pretty_total_line
+
+    assert "- Total:" in out
+    assert "USD" in out
+    assert "1.234567" in out
+
+
+# ---------- tests: MULTILINE OUTPUT ----------
+
+def test_pretty_multiline_output() -> None:
+    """
+    Should produce a full formatted cost report with all parts.
+    """
+    report = CostReportSchema(
+        model="gpt-4o-mini",
+        prompt_tokens=200,
+        completion_tokens=100,
+        input_cost=0.002,
+        output_cost=0.001,
+        total_cost=0.003,
+    )
+
+    out = report.pretty()
+
+    assert out.startswith("\n💰 Estimated Cost for `gpt-4o-mini`")
+    assert "- Prompt tokens:" in out
+    assert "- Completion tokens:" in out
+    assert "- Total:" in out
+    assert out.count("\n") >= 4