xai-review 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

ai_review/libs/constants/llm_provider.py

@@ -5,3 +5,4 @@ class LLMProvider(StrEnum):
     OPENAI = "OPENAI"
     GEMINI = "GEMINI"
     CLAUDE = "CLAUDE"
+    OLLAMA = "OLLAMA"

ai_review/libs/constants/vcs_provider.py

@@ -4,3 +4,4 @@ from enum import StrEnum
 class VCSProvider(StrEnum):
     GITHUB = "GITHUB"
     GITLAB = "GITLAB"
+    BITBUCKET = "BITBUCKET"

ai_review/services/llm/factory.py

@@ -2,6 +2,7 @@ from ai_review.config import settings
 from ai_review.libs.constants.llm_provider import LLMProvider
 from ai_review.services.llm.claude.client import ClaudeLLMClient
 from ai_review.services.llm.gemini.client import GeminiLLMClient
+from ai_review.services.llm.ollama.client import OllamaLLMClient
 from ai_review.services.llm.openai.client import OpenAILLMClient
 from ai_review.services.llm.types import LLMClientProtocol
 
@@ -14,5 +15,7 @@ def get_llm_client() -> LLMClientProtocol:
             return GeminiLLMClient()
         case LLMProvider.CLAUDE:
             return ClaudeLLMClient()
+        case LLMProvider.OLLAMA:
+            return OllamaLLMClient()
         case _:
             raise ValueError(f"Unsupported LLM provider: {settings.llm.provider}")

ai_review/services/llm/ollama/client.py

@@ -0,0 +1,34 @@
+from ai_review.clients.ollama.client import get_ollama_http_client
+from ai_review.clients.ollama.schema import OllamaChatRequestSchema, OllamaMessageSchema, OllamaOptionsSchema
+from ai_review.config import settings
+from ai_review.services.llm.types import LLMClientProtocol, ChatResultSchema
+
+
+class OllamaLLMClient(LLMClientProtocol):
+    def __init__(self):
+        self.http_client = get_ollama_http_client()
+
+    async def chat(self, prompt: str, prompt_system: str) -> ChatResultSchema:
+        meta = settings.llm.meta
+        request = OllamaChatRequestSchema(
+            model=meta.model,
+            options=OllamaOptionsSchema(
+                stop=meta.stop,
+                seed=meta.seed,
+                top_p=meta.top_p,
+                temperature=meta.temperature,
+                num_predict=meta.max_tokens,
+                repeat_penalty=meta.repeat_penalty,
+            ),
+            messages=[
+                OllamaMessageSchema(role="system", content=prompt_system),
+                OllamaMessageSchema(role="user", content=prompt),
+            ],
+        )
+        response = await self.http_client.chat(request)
+        return ChatResultSchema(
+            text=response.first_text,
+            total_tokens=response.usage.total_tokens if response.usage else None,
+            prompt_tokens=response.usage.prompt_tokens if response.usage else None,
+            completion_tokens=response.usage.completion_tokens if response.usage else None,
+        )

ai_review/services/vcs/bitbucket/client.py

@@ -0,0 +1,185 @@
+from ai_review.clients.bitbucket.client import get_bitbucket_http_client
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketCommentInlineSchema,
+    BitbucketCommentContentSchema,
+    BitbucketCreatePRCommentRequestSchema,
+)
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.types import (
+    VCSClientProtocol,
+    UserSchema,
+    BranchRefSchema,
+    ReviewInfoSchema,
+    ReviewCommentSchema,
+)
+
+logger = get_logger("BITBUCKET_VCS_CLIENT")
+
+
+class BitbucketVCSClient(VCSClientProtocol):
+    def __init__(self):
+        self.http_client = get_bitbucket_http_client()
+        self.workspace = settings.vcs.pipeline.workspace
+        self.repo_slug = settings.vcs.pipeline.repo_slug
+        self.pull_request_id = settings.vcs.pipeline.pull_request_id
+
+    async def get_review_info(self) -> ReviewInfoSchema:
+        try:
+            pr = await self.http_client.pr.get_pull_request(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            files = await self.http_client.pr.get_files(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+
+            logger.info(f"Fetched PR info for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+
+            return ReviewInfoSchema(
+                id=pr.id,
+                title=pr.title,
+                description=pr.description or "",
+                author=UserSchema(
+                    id=pr.author.uuid,
+                    name=pr.author.display_name,
+                    username=pr.author.nickname,
+                ),
+                labels=[],
+                base_sha=pr.destination.commit.hash,
+                head_sha=pr.source.commit.hash,
+                assignees=[
+                    UserSchema(
+                        id=user.uuid,
+                        name=user.display_name,
+                        username=user.nickname,
+                    )
+                    for user in pr.participants
+                ],
+                reviewers=[
+                    UserSchema(
+                        id=user.uuid,
+                        name=user.display_name,
+                        username=user.nickname,
+                    )
+                    for user in pr.reviewers
+                ],
+                source_branch=BranchRefSchema(
+                    ref=pr.source.branch.name,
+                    sha=pr.source.commit.hash,
+                ),
+                target_branch=BranchRefSchema(
+                    ref=pr.destination.branch.name,
+                    sha=pr.destination.commit.hash,
+                ),
+                changed_files=[
+                    file.new.path if file.new else file.old.path
+                    for file in files.values
+                ],
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch PR info {self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            return ReviewInfoSchema()
+
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_comments(
+                workspace=self.workspace,
+                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}")
+
+            return [
+                ReviewCommentSchema(id=comment.id, body=comment.content.raw)
+                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}"
+            )
+            return []
+
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_comments(
+                workspace=self.workspace,
+                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}")
+
+            return [
+                ReviewCommentSchema(
+                    id=comment.id,
+                    body=comment.content.raw,
+                    file=comment.inline.path,
+                    line=comment.inline.to_line,
+                )
+                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}"
+            )
+            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}"
+            )
+            request = BitbucketCreatePRCommentRequestSchema(
+                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 general comment in PR {self.workspace}/{self.repo_slug}#{self.pull_request_id}"
+            )
+        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}"
+            )
+            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}"
+            )
+            request = BitbucketCreatePRCommentRequestSchema(
+                content=BitbucketCommentContentSchema(raw=message),
+                inline=BitbucketCommentInlineSchema(path=file, to_line=line),
+            )
+            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 comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
+                f"at {file}:{line}"
+            )
+        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}"
+            )
+            raise

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.bitbucket.client import BitbucketVCSClient
 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 VCSClientProtocol
@@ -11,5 +12,7 @@ def get_vcs_client() -> VCSClientProtocol:
             return GitLabVCSClient()
         case VCSProvider.GITHUB:
             return GitHubVCSClient()
+        case VCSProvider.BITBUCKET:
+            return BitbucketVCSClient()
         case _:
             raise ValueError(f"Unsupported VCS provider: {settings.vcs.provider}")

ai_review/tests/fixtures/clients/bitbucket.py

@@ -0,0 +1,204 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketPRCommentSchema,
+    BitbucketCommentContentSchema,
+    BitbucketCommentInlineSchema,
+    BitbucketGetPRCommentsResponseSchema,
+    BitbucketCreatePRCommentRequestSchema,
+    BitbucketCreatePRCommentResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.files import (
+    BitbucketGetPRFilesResponseSchema,
+    BitbucketPRFileSchema,
+    BitbucketPRFilePathSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.pull_request import (
+    BitbucketUserSchema,
+    BitbucketBranchSchema,
+    BitbucketCommitSchema,
+    BitbucketRepositorySchema,
+    BitbucketPRLocationSchema,
+    BitbucketGetPRResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.types import BitbucketPullRequestsHTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.vcs.base import BitbucketVCSConfig
+from ai_review.libs.config.vcs.bitbucket import BitbucketPipelineConfig, BitbucketHTTPClientConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
+
+
+class FakeBitbucketPullRequestsHTTPClient(BitbucketPullRequestsHTTPClientProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    async def get_pull_request(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRResponseSchema:
+        self.calls.append(
+            (
+                "get_pull_request",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRResponseSchema(
+            id=1,
+            title="Fake Bitbucket PR",
+            description="This is a fake PR for testing",
+            state="OPEN",
+            author=BitbucketUserSchema(uuid="u1", display_name="Tester", nickname="tester"),
+            source=BitbucketPRLocationSchema(
+                commit=BitbucketCommitSchema(hash="def456"),
+                branch=BitbucketBranchSchema(name="feature/test"),
+                repository=BitbucketRepositorySchema(uuid="r1", full_name="workspace/repo"),
+            ),
+            destination=BitbucketPRLocationSchema(
+                commit=BitbucketCommitSchema(hash="abc123"),
+                branch=BitbucketBranchSchema(name="main"),
+                repository=BitbucketRepositorySchema(uuid="r1", full_name="workspace/repo"),
+            ),
+            reviewers=[BitbucketUserSchema(uuid="u2", display_name="Reviewer", nickname="reviewer")],
+            participants=[BitbucketUserSchema(uuid="u3", display_name="Participant", nickname="participant")],
+        )
+
+    async def get_files(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRFilesResponseSchema:
+        self.calls.append(
+            (
+                "get_files",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRFilesResponseSchema(
+            size=2,
+            page=1,
+            pagelen=100,
+            next=None,
+            values=[
+                BitbucketPRFileSchema(
+                    new=BitbucketPRFilePathSchema(path="app/main.py"),
+                    old=None,
+                    status="modified",
+                    lines_added=10,
+                    lines_removed=2,
+                ),
+                BitbucketPRFileSchema(
+                    new=BitbucketPRFilePathSchema(path="utils/helper.py"),
+                    old=None,
+                    status="added",
+                    lines_added=5,
+                    lines_removed=0,
+                ),
+            ],
+        )
+
+    async def get_comments(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRCommentsResponseSchema:
+        self.calls.append(
+            (
+                "get_comments",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRCommentsResponseSchema(
+            size=2,
+            page=1,
+            next=None,
+            values=[
+                BitbucketPRCommentSchema(
+                    id=1,
+                    inline=None,
+                    content=BitbucketCommentContentSchema(raw="General comment"),
+                ),
+                BitbucketPRCommentSchema(
+                    id=2,
+                    inline=BitbucketCommentInlineSchema(path="file.py", to_line=5),
+                    content=BitbucketCommentContentSchema(raw="Inline comment"),
+                ),
+            ],
+            pagelen=100,
+        )
+
+    async def create_comment(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            request: BitbucketCreatePRCommentRequestSchema
+    ) -> BitbucketCreatePRCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_comment",
+                {
+                    "workspace": workspace,
+                    "repo_slug": repo_slug,
+                    "pull_request_id": pull_request_id,
+                    **request.model_dump(by_alias=True)
+                }
+            )
+        )
+        return BitbucketCreatePRCommentResponseSchema(
+            id=10,
+            content=request.content,
+            inline=request.inline,
+        )
+
+
+class FakeBitbucketHTTPClient:
+    def __init__(self, pull_requests_client: BitbucketPullRequestsHTTPClientProtocol):
+        self.pr = pull_requests_client
+
+
+@pytest.fixture
+def fake_bitbucket_pull_requests_http_client() -> FakeBitbucketPullRequestsHTTPClient:
+    return FakeBitbucketPullRequestsHTTPClient()
+
+
+@pytest.fixture
+def fake_bitbucket_http_client(
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient
+) -> FakeBitbucketHTTPClient:
+    return FakeBitbucketHTTPClient(pull_requests_client=fake_bitbucket_pull_requests_http_client)
+
+
+@pytest.fixture
+def bitbucket_vcs_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_bitbucket_http_client: FakeBitbucketHTTPClient
+) -> BitbucketVCSClient:
+    monkeypatch.setattr(
+        "ai_review.services.vcs.bitbucket.client.get_bitbucket_http_client",
+        lambda: fake_bitbucket_http_client,
+    )
+    return BitbucketVCSClient()
+
+
+@pytest.fixture
+def bitbucket_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = BitbucketVCSConfig(
+        provider=VCSProvider.BITBUCKET,
+        pipeline=BitbucketPipelineConfig(
+            workspace="workspace",
+            repo_slug="repo",
+            pull_request_id="123",
+        ),
+        http_client=BitbucketHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://api.bitbucket.org/2.0"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "vcs", fake_config)

ai_review/tests/fixtures/clients/claude.py

@@ -1,10 +1,55 @@
+from typing import Any
+
 import pytest
 from pydantic import HttpUrl, SecretStr
 
+from ai_review.clients.claude.schema import (
+    ClaudeUsageSchema,
+    ClaudeContentSchema,
+    ClaudeChatRequestSchema,
+    ClaudeChatResponseSchema,
+)
+from ai_review.clients.claude.types import ClaudeHTTPClientProtocol
 from ai_review.config import settings
 from ai_review.libs.config.llm.base import ClaudeLLMConfig
 from ai_review.libs.config.llm.claude import ClaudeMetaConfig, ClaudeHTTPClientConfig
 from ai_review.libs.constants.llm_provider import LLMProvider
+from ai_review.services.llm.claude.client import ClaudeLLMClient
+
+
+class FakeClaudeHTTPClient(ClaudeHTTPClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, dict]] = []
+        self.responses = responses or {}
+
+    async def chat(self, request: ClaudeChatRequestSchema) -> ClaudeChatResponseSchema:
+        self.calls.append(("chat", {"request": request}))
+        return self.responses.get(
+            "chat",
+            ClaudeChatResponseSchema(
+                id="fake-id",
+                role="assistant",
+                usage=ClaudeUsageSchema(input_tokens=5, output_tokens=7),
+                content=[ClaudeContentSchema(type="text", text="FAKE_CLAUDE_RESPONSE")],
+            ),
+        )
+
+
+@pytest.fixture
+def fake_claude_http_client():
+    return FakeClaudeHTTPClient()
+
+
+@pytest.fixture
+def claude_llm_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_claude_http_client: FakeClaudeHTTPClient
+) -> ClaudeLLMClient:
+    monkeypatch.setattr(
+        "ai_review.services.llm.claude.client.get_claude_http_client",
+        lambda: fake_claude_http_client,
+    )
+    return ClaudeLLMClient()
 
 
 @pytest.fixture

ai_review/tests/fixtures/clients/gemini.py

@@ -1,10 +1,62 @@
+from typing import Any
+
 import pytest
 from pydantic import HttpUrl, SecretStr
 
+from ai_review.clients.gemini.schema import (
+    GeminiPartSchema,
+    GeminiUsageSchema,
+    GeminiContentSchema,
+    GeminiCandidateSchema,
+    GeminiChatRequestSchema,
+    GeminiChatResponseSchema,
+)
+from ai_review.clients.gemini.types import GeminiHTTPClientProtocol
 from ai_review.config import settings
 from ai_review.libs.config.llm.base import GeminiLLMConfig
 from ai_review.libs.config.llm.gemini import GeminiMetaConfig, GeminiHTTPClientConfig
 from ai_review.libs.constants.llm_provider import LLMProvider
+from ai_review.services.llm.gemini.client import GeminiLLMClient
+
+
+class FakeGeminiHTTPClient(GeminiHTTPClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, dict]] = []
+        self.responses = responses or {}
+
+    async def chat(self, request: GeminiChatRequestSchema) -> GeminiChatResponseSchema:
+        self.calls.append(("chat", {"request": request}))
+        return self.responses.get(
+            "chat",
+            GeminiChatResponseSchema(
+                usage=GeminiUsageSchema(prompt_token_count=2, total_tokens_count=10),
+                candidates=[
+                    GeminiCandidateSchema(
+                        content=GeminiContentSchema(
+                            role="model",
+                            parts=[GeminiPartSchema(text="FAKE_GEMINI_RESPONSE")]
+                        )
+                    )
+                ],
+            ),
+        )
+
+
+@pytest.fixture
+def fake_gemini_http_client() -> FakeGeminiHTTPClient:
+    return FakeGeminiHTTPClient()
+
+
+@pytest.fixture
+def gemini_llm_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_gemini_http_client: FakeGeminiHTTPClient
+) -> GeminiLLMClient:
+    monkeypatch.setattr(
+        "ai_review.services.llm.gemini.client.get_gemini_http_client",
+        lambda: fake_gemini_http_client,
+    )
+    return GeminiLLMClient()
 
 
 @pytest.fixture

ai_review/tests/fixtures/clients/ollama.py

@@ -0,0 +1,65 @@
+from typing import Any
+
+import pytest
+from pydantic import HttpUrl
+
+from ai_review.clients.ollama.schema import (
+    OllamaUsageSchema,
+    OllamaMessageSchema,
+    OllamaChatRequestSchema,
+    OllamaChatResponseSchema,
+)
+from ai_review.clients.ollama.types import OllamaHTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.llm.base import OllamaLLMConfig
+from ai_review.libs.config.llm.ollama import OllamaMetaConfig, OllamaHTTPClientConfig
+from ai_review.libs.constants.llm_provider import LLMProvider
+from ai_review.services.llm.ollama.client import OllamaLLMClient
+
+
+class FakeOllamaHTTPClient(OllamaHTTPClientProtocol):
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.calls: list[tuple[str, dict]] = []
+        self.responses = responses or {}
+
+    async def chat(self, request: OllamaChatRequestSchema) -> OllamaChatResponseSchema:
+        self.calls.append(("chat", {"request": request}))
+        return self.responses.get(
+            "chat",
+            OllamaChatResponseSchema(
+                done=True,
+                model="llama2",
+                usage=OllamaUsageSchema(prompt_tokens=3, completion_tokens=5),
+                message=OllamaMessageSchema(role="assistant", content="FAKE_OLLAMA_RESPONSE"),
+            ),
+        )
+
+
+@pytest.fixture
+def fake_ollama_http_client():
+    return FakeOllamaHTTPClient()
+
+
+@pytest.fixture
+def ollama_llm_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_ollama_http_client: FakeOllamaHTTPClient
+) -> OllamaLLMClient:
+    monkeypatch.setattr(
+        "ai_review.services.llm.ollama.client.get_ollama_http_client",
+        lambda: fake_ollama_http_client,
+    )
+    return OllamaLLMClient()
+
+
+@pytest.fixture
+def ollama_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = OllamaLLMConfig(
+        meta=OllamaMetaConfig(),
+        provider=LLMProvider.OLLAMA,
+        http_client=OllamaHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("http://localhost:11434")
+        )
+    )
+    monkeypatch.setattr(settings, "llm", fake_config)