xai-review 0.3.0__py3-none-any.whl

ai_review/cli/commands/run_context_review.py

@@ -0,0 +1,7 @@
+from ai_review.services.review.service import ReviewService
+
+
+async def run_context_review_command():
+    review_service = ReviewService()
+    await review_service.run_context_review()
+    review_service.report_total_cost()

ai_review/cli/commands/run_inline_review.py

@@ -0,0 +1,7 @@
+from ai_review.services.review.service import ReviewService
+
+
+async def run_inline_review_command():
+    review_service = ReviewService()
+    await review_service.run_inline_review()
+    review_service.report_total_cost()

ai_review/cli/commands/run_review.py

@@ -0,0 +1,8 @@
+from ai_review.services.review.service import ReviewService
+
+
+async def run_review_command():
+    review_service = ReviewService()
+    await review_service.run_inline_review()
+    await review_service.run_summary_review()
+    review_service.report_total_cost()

ai_review/cli/commands/run_summary_review.py

@@ -0,0 +1,7 @@
+from ai_review.services.review.service import ReviewService
+
+
+async def run_summary_review_command():
+    review_service = ReviewService()
+    await review_service.run_summary_review()
+    review_service.report_total_cost()

ai_review/cli/main.py

@@ -0,0 +1,54 @@
+import asyncio
+
+import typer
+
+from ai_review.cli.commands.run_context_review import run_context_review_command
+from ai_review.cli.commands.run_inline_review import run_inline_review_command
+from ai_review.cli.commands.run_review import run_review_command
+from ai_review.cli.commands.run_summary_review import run_summary_review_command
+from ai_review.config import settings
+
+app = typer.Typer(help="AI Review CLI")
+
+
+@app.command("run")
+def run():
+    """Run the full AI review pipeline"""
+    typer.secho("Starting full AI review...", fg=typer.colors.CYAN, bold=True)
+    asyncio.run(run_review_command())
+    typer.secho("AI review completed successfully!", fg=typer.colors.GREEN, bold=True)
+
+
+@app.command("run-inline")
+def run_inline():
+    """Run only the inline review"""
+    typer.secho("Starting inline AI review...", fg=typer.colors.CYAN)
+    asyncio.run(run_inline_review_command())
+    typer.secho("AI review completed successfully!", fg=typer.colors.GREEN, bold=True)
+
+
+@app.command("run-context")
+def run_context():
+    """Run only the context review"""
+    typer.secho("Starting context AI review...", fg=typer.colors.CYAN)
+    asyncio.run(run_context_review_command())
+    typer.secho("AI review completed successfully!", fg=typer.colors.GREEN, bold=True)
+
+
+@app.command("run-summary")
+def run_summary():
+    """Run only the summary review"""
+    typer.secho("Starting summary AI review...", fg=typer.colors.CYAN)
+    asyncio.run(run_summary_review_command())
+    typer.secho("AI review completed successfully!", fg=typer.colors.GREEN, bold=True)
+
+
+@app.command("show-config")
+def show_config():
+    """Show the current resolved configuration"""
+    typer.secho("Loaded AI Review configuration:", fg=typer.colors.CYAN, bold=True)
+    typer.echo(settings.model_dump_json(indent=2, exclude_none=True))
+
+
+if __name__ == "__main__":
+    app()

ai_review/clients/claude/client.py

@@ -0,0 +1,44 @@
+from httpx import AsyncClient, Response, AsyncHTTPTransport
+
+from ai_review.clients.claude.schema import ClaudeChatRequestSchema, ClaudeChatResponseSchema
+from ai_review.config import settings
+from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.event_hooks.logger import LoggerEventHook
+from ai_review.libs.http.handlers import HTTPClientError, handle_http_error
+from ai_review.libs.http.transports.retry import RetryTransport
+from ai_review.libs.logger import get_logger
+
+
+class ClaudeHTTPClientError(HTTPClientError):
+    pass
+
+
+class ClaudeHTTPClient(HTTPClient):
+    @handle_http_error(client="ClaudeHTTPClient", exception=ClaudeHTTPClientError)
+    async def chat_api(self, request: ClaudeChatRequestSchema) -> Response:
+        return await self.post("/v1/messages", json=request.model_dump())
+
+    async def chat(self, request: ClaudeChatRequestSchema) -> ClaudeChatResponseSchema:
+        response = await self.chat_api(request)
+        return ClaudeChatResponseSchema.model_validate_json(response.text)
+
+
+def get_claude_http_client() -> ClaudeHTTPClient:
+    logger = get_logger("CLAUDE_HTTP_CLIENT")
+    logger_event_hook = LoggerEventHook(logger=logger)
+    retry_transport = RetryTransport(transport=AsyncHTTPTransport())
+
+    client = AsyncClient(
+        timeout=settings.llm.http_client.timeout,
+        headers={
+            "x-api-key": settings.llm.http_client.api_key,
+            "anthropic-version": settings.llm.http_client.api_version,
+        },
+        base_url=settings.llm.http_client.base_url,
+        transport=retry_transport,
+        event_hooks={
+            "request": [logger_event_hook.request],
+            "response": [logger_event_hook.response],
+        },
+    )
+    return ClaudeHTTPClient(client=client)

ai_review/clients/claude/schema.py

@@ -0,0 +1,44 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class ClaudeMessageSchema(BaseModel):
+    role: Literal["user", "assistant", "system"]
+    content: str
+
+
+class ClaudeChatRequestSchema(BaseModel):
+    model: str
+    system: str | None = None
+    messages: list[ClaudeMessageSchema]
+    max_tokens: int
+    temperature: float
+
+
+class ClaudeContentSchema(BaseModel):
+    type: Literal["text"]
+    text: str
+
+
+class ClaudeUsageSchema(BaseModel):
+    input_tokens: int
+    output_tokens: int
+
+    @property
+    def total_tokens(self) -> int:
+        return self.input_tokens + self.output_tokens
+
+
+class ClaudeChatResponseSchema(BaseModel):
+    id: str
+    role: str
+    usage: ClaudeUsageSchema
+    content: list[ClaudeContentSchema]
+
+    @property
+    def first_text(self) -> str:
+        if not self.content:
+            return ""
+
+        return self.content[0].text.strip()

ai_review/clients/gemini/client.py

@@ -0,0 +1,45 @@
+from httpx import Response, AsyncHTTPTransport, AsyncClient
+
+from ai_review.clients.gemini.schema import GeminiChatRequestSchema, GeminiChatResponseSchema
+from ai_review.config import settings
+from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.event_hooks.logger import LoggerEventHook
+from ai_review.libs.http.handlers import HTTPClientError, handle_http_error
+from ai_review.libs.http.transports.retry import RetryTransport
+from ai_review.libs.logger import get_logger
+
+
+class GeminiHTTPClientError(HTTPClientError):
+    pass
+
+
+class GeminiHTTPClient(HTTPClient):
+    @handle_http_error(client="GeminiHTTPClient", exception=GeminiHTTPClientError)
+    async def chat_api(self, request: GeminiChatRequestSchema) -> Response:
+        meta = settings.llm.meta
+        return await self.post(
+            f"/v1beta/models/{meta.model}:generateContent", json=request.model_dump()
+        )
+
+    async def chat(self, request: GeminiChatRequestSchema) -> GeminiChatResponseSchema:
+        response = await self.chat_api(request)
+        return GeminiChatResponseSchema.model_validate_json(response.text)
+
+
+def get_gemini_http_client() -> GeminiHTTPClient:
+    logger = get_logger("GEMINI_HTTP_CLIENT")
+    logger_event_hook = LoggerEventHook(logger=logger)
+    retry_transport = RetryTransport(transport=AsyncHTTPTransport())
+
+    client = AsyncClient(
+        timeout=settings.llm.http_client.timeout,
+        headers={"x-goog-api-key": settings.llm.http_client.api_key},
+        base_url=settings.llm.http_client.base_url,
+        transport=retry_transport,
+        event_hooks={
+            "request": [logger_event_hook.request],
+            "response": [logger_event_hook.response],
+        },
+    )
+
+    return GeminiHTTPClient(client=client)

ai_review/clients/gemini/schema.py

@@ -0,0 +1,78 @@
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class GeminiPartSchema(BaseModel):
+    text: str
+
+
+class GeminiUsageSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    prompt_token_count: int = Field(alias="promptTokenCount")
+    total_tokens_count: int | None = Field(default=None, alias="totalTokenCount")
+    candidates_token_count: int | None = Field(default=None, alias="candidatesTokenCount")
+    output_thoughts_token_count: int | None = Field(default=None, alias="outputThoughtsTokenCount")
+
+    @property
+    def total_tokens(self) -> int:
+        if self.total_tokens_count is not None:
+            return self.total_tokens_count
+
+        return (
+                (self.prompt_token_count or 0)
+                + (self.candidates_token_count or 0)
+                + (self.output_thoughts_token_count or 0)
+        )
+
+    @property
+    def prompt_tokens(self) -> int:
+        return self.prompt_token_count
+
+    @property
+    def completion_tokens(self) -> int | None:
+        return self.candidates_token_count or self.output_thoughts_token_count
+
+
+class GeminiContentSchema(BaseModel):
+    role: str = "user"
+    parts: list[GeminiPartSchema] | None = None
+
+
+class GeminiCandidateSchema(BaseModel):
+    content: GeminiContentSchema
+
+
+class GeminiGenerationConfigSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    temperature: float
+    max_output_tokens: int = Field(alias="maxOutputTokens")
+
+
+class GeminiChatRequestSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    contents: list[GeminiContentSchema]
+    generation_config: GeminiGenerationConfigSchema | None = Field(
+        alias="generationConfig",
+        default=None
+    )
+    system_instruction: GeminiContentSchema | None = Field(
+        alias="systemInstruction",
+        default=None
+    )
+
+
+class GeminiChatResponseSchema(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    usage: GeminiUsageSchema = Field(alias="usageMetadata")
+    candidates: list[GeminiCandidateSchema]
+
+    @property
+    def first_text(self) -> str:
+        if not self.candidates:
+            return ""
+
+        parts = self.candidates[0].content.parts or []
+        return (parts[0].text if parts else "").strip()

ai_review/clients/gitlab/client.py

@@ -0,0 +1,31 @@
+from httpx import AsyncClient, AsyncHTTPTransport
+
+from ai_review.clients.gitlab.mr.client import GitLabMergeRequestsHTTPClient
+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 GitLabHTTPClient:
+    def __init__(self, client: AsyncClient):
+        self.mr = GitLabMergeRequestsHTTPClient(client)
+
+
+def get_gitlab_http_client() -> GitLabHTTPClient:
+    logger = get_logger("GITLAB_MERGE_REQUESTS_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.bearer_token}"},
+        base_url=settings.vcs.http_client.base_url,
+        transport=retry_transport,
+        event_hooks={
+            'request': [logger_event_hook.request],
+            'response': [logger_event_hook.response]
+        }
+    )
+
+    return GitLabHTTPClient(client=client)

ai_review/clients/gitlab/mr/client.py

@@ -0,0 +1,101 @@
+from httpx import Response
+
+from ai_review.clients.gitlab.mr.schema.changes import GitLabGetMRChangesResponseSchema
+from ai_review.clients.gitlab.mr.schema.comments import (
+    GitLabGetMRCommentsResponseSchema,
+    GitLabCreateMRCommentRequestSchema,
+    GitLabCreateMRCommentResponseSchema,
+)
+from ai_review.clients.gitlab.mr.schema.discussions import (
+    GitLabGetMRDiscussionsResponseSchema,
+    GitLabCreateMRDiscussionRequestSchema,
+    GitLabCreateMRDiscussionResponseSchema
+)
+from ai_review.libs.http.client import HTTPClient
+
+
+class GitLabMergeRequestsHTTPClient(HTTPClient):
+
+    async def get_changes_api(self, project_id: str, merge_request_id: str) -> Response:
+        return await self.get(
+            f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/changes"
+        )
+
+    async def get_comments_api(self, project_id: str, merge_request_id: str) -> Response:
+        return await self.get(
+            f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/notes"
+        )
+
+    async def get_discussions_api(self, project_id: str, merge_request_id: str) -> Response:
+        return await self.get(
+            f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/discussions"
+        )
+
+    async def create_comment_api(
+            self,
+            project_id: str,
+            merge_request_id: str,
+            request: GitLabCreateMRCommentRequestSchema,
+    ) -> Response:
+        return await self.post(
+            f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/notes",
+            json=request.model_dump(),
+        )
+
+    async def create_discussion_api(
+            self,
+            project_id: str,
+            merge_request_id: str,
+            request: GitLabCreateMRDiscussionRequestSchema,
+    ) -> Response:
+        return await self.post(
+            f"/api/v4/projects/{project_id}/merge_requests/{merge_request_id}/discussions",
+            json=request.model_dump(),
+        )
+
+    async def get_changes(self, project_id: str, merge_request_id: str) -> GitLabGetMRChangesResponseSchema:
+        response = await self.get_changes_api(project_id, merge_request_id)
+        return GitLabGetMRChangesResponseSchema.model_validate_json(response.text)
+
+    async def get_comments(
+            self,
+            project_id: str,
+            merge_request_id: str
+    ) -> GitLabGetMRCommentsResponseSchema:
+        response = await self.get_comments_api(project_id, merge_request_id)
+        return GitLabGetMRCommentsResponseSchema.model_validate_json(response.text)
+
+    async def get_discussions(
+            self,
+            project_id: str,
+            merge_request_id: str
+    ) -> GitLabGetMRDiscussionsResponseSchema:
+        response = await self.get_discussions_api(project_id, merge_request_id)
+        return GitLabGetMRDiscussionsResponseSchema.model_validate_json(response.text)
+
+    async def create_comment(
+            self,
+            comment: str,
+            project_id: str,
+            merge_request_id: str,
+    ) -> GitLabCreateMRCommentResponseSchema:
+        request = GitLabCreateMRCommentRequestSchema(body=comment)
+        response = await self.create_comment_api(
+            request=request,
+            project_id=project_id,
+            merge_request_id=merge_request_id
+        )
+        return GitLabCreateMRCommentResponseSchema.model_validate_json(response.text)
+
+    async def create_discussion(
+            self,
+            project_id: str,
+            merge_request_id: str,
+            request: GitLabCreateMRDiscussionRequestSchema
+    ):
+        response = await self.create_discussion_api(
+            request=request,
+            project_id=project_id,
+            merge_request_id=merge_request_id
+        )
+        return GitLabCreateMRDiscussionResponseSchema.model_validate_json(response.text)

ai_review/clients/gitlab/mr/schema/changes.py

@@ -0,0 +1,35 @@
+from pydantic import BaseModel, Field
+
+
+class GitLabUserSchema(BaseModel):
+    id: int
+    name: str
+    username: str
+
+
+class GitLabDiffRefsSchema(BaseModel):
+    base_sha: str
+    head_sha: str
+    start_sha: str
+
+
+class GitLabMRChangeSchema(BaseModel):
+    diff: str
+    old_path: str
+    new_path: str
+
+
+class GitLabGetMRChangesResponseSchema(BaseModel):
+    id: int
+    iid: int
+    title: str
+    author: GitLabUserSchema
+    labels: list[str] = []
+    changes: list[GitLabMRChangeSchema]
+    assignees: list[GitLabUserSchema] = Field(default_factory=list)
+    reviewers: list[GitLabUserSchema] = Field(default_factory=list)
+    diff_refs: GitLabDiffRefsSchema
+    project_id: int
+    description: str
+    source_branch: str
+    target_branch: str

ai_review/clients/gitlab/mr/schema/comments.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, RootModel
+
+
+class GitLabMRCommentSchema(BaseModel):
+    id: int
+    body: str
+
+
+class GitLabGetMRCommentsResponseSchema(RootModel[list[GitLabMRCommentSchema]]):
+    root: list[GitLabMRCommentSchema]
+
+
+class GitLabCreateMRCommentRequestSchema(BaseModel):
+    body: str
+
+
+class GitLabCreateMRCommentResponseSchema(BaseModel):
+    id: int
+    body: str

ai_review/clients/gitlab/mr/schema/discussions.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel, RootModel
+
+
+class GitLabNoteSchema(BaseModel):
+    id: int
+    body: str
+
+
+class GitLabDiscussionSchema(BaseModel):
+    id: str
+    notes: list[GitLabNoteSchema]
+
+
+class GitLabDiscussionPositionSchema(BaseModel):
+    position_type: str = "text"
+    base_sha: str
+    head_sha: str
+    start_sha: str
+    new_path: str
+    new_line: int
+
+
+class GitLabGetMRDiscussionsResponseSchema(RootModel[list[GitLabDiscussionSchema]]):
+    root: list[GitLabDiscussionSchema]
+
+
+class GitLabCreateMRDiscussionRequestSchema(BaseModel):
+    body: str
+    position: GitLabDiscussionPositionSchema
+
+
+class GitLabCreateMRDiscussionResponseSchema(BaseModel):
+    id: str
+    body: str | None = None

ai_review/clients/openai/client.py

@@ -0,0 +1,42 @@
+from httpx import Response, AsyncHTTPTransport, AsyncClient
+
+from ai_review.clients.openai.schema import OpenAIChatRequestSchema, OpenAIChatResponseSchema
+from ai_review.config import settings
+from ai_review.libs.http.client import HTTPClient
+from ai_review.libs.http.event_hooks.logger import LoggerEventHook
+from ai_review.libs.http.handlers import HTTPClientError, handle_http_error
+from ai_review.libs.http.transports.retry import RetryTransport
+from ai_review.libs.logger import get_logger
+
+
+class OpenAIHTTPClientError(HTTPClientError):
+    pass
+
+
+class OpenAIHTTPClient(HTTPClient):
+    @handle_http_error(client='OpenAIHTTPClient', exception=OpenAIHTTPClientError)
+    async def chat_api(self, request: OpenAIChatRequestSchema) -> Response:
+        return await self.post("/chat/completions", json=request.model_dump())
+
+    async def chat(self, request: OpenAIChatRequestSchema) -> OpenAIChatResponseSchema:
+        response = await self.chat_api(request)
+        return OpenAIChatResponseSchema.model_validate_json(response.text)
+
+
+def get_openai_http_client() -> OpenAIHTTPClient:
+    logger = get_logger("OPENAI_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.llm.http_client.bearer_token}"},
+        base_url=settings.llm.http_client.base_url,
+        transport=retry_transport,
+        event_hooks={
+            'request': [logger_event_hook.request],
+            'response': [logger_event_hook.response]
+        }
+    )
+
+    return OpenAIHTTPClient(client=client)

ai_review/clients/openai/schema.py

@@ -0,0 +1,37 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class OpenAIUsageSchema(BaseModel):
+    total_tokens: int
+    prompt_tokens: int
+    completion_tokens: int
+
+
+class OpenAIMessageSchema(BaseModel):
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+
+class OpenAIChoiceSchema(BaseModel):
+    message: OpenAIMessageSchema
+
+
+class OpenAIChatRequestSchema(BaseModel):
+    model: str
+    messages: list[OpenAIMessageSchema]
+    max_tokens: int
+    temperature: float
+
+
+class OpenAIChatResponseSchema(BaseModel):
+    usage: OpenAIUsageSchema
+    choices: list[OpenAIChoiceSchema]
+
+    @property
+    def first_text(self) -> str:
+        if not self.choices:
+            return ""
+
+        return (self.choices[0].message.content or "").strip()