xai-review 0.3.0__py3-none-any.whl

ai_review/services/review/inline/schema.py

@@ -0,0 +1,53 @@
+from typing import Self
+
+from pydantic import BaseModel, Field, RootModel, field_validator
+
+from ai_review.config import settings
+
+DedupKey = tuple[str, int, str]
+
+
+class InlineCommentSchema(BaseModel):
+    file: str = Field(min_length=1)
+    line: int = Field(ge=1)
+    message: str = Field(min_length=1)
+    suggestion: str | None = None
+
+    @field_validator("file")
+    def normalize_file(cls, value: str) -> str:
+        value = value.strip().replace("\\", "/")
+        return value.lstrip("/")
+
+    @field_validator("message")
+    def normalize_message(cls, value: str) -> str:
+        return value.strip()
+
+    @property
+    def dedup_key(self) -> DedupKey:
+        return self.file, self.line, (self.suggestion or self.message).strip().lower()
+
+    @property
+    def body(self) -> str:
+        if self.suggestion:
+            return f"{self.message}\n\n```suggestion\n{self.suggestion}\n```"
+
+        return self.message
+
+    @property
+    def body_with_tag(self) -> str:
+        return f"{self.body}\n\n{settings.review.inline_tag}"
+
+    @property
+    def fallback_body_with_tag(self) -> str:
+        return f"**{self.file}:{self.line}** — {self.message}\n\n{settings.review.inline_tag}"
+
+
+class InlineCommentListSchema(RootModel[list[InlineCommentSchema]]):
+    root: list[InlineCommentSchema]
+
+    def dedupe(self) -> Self:
+        results_map: dict[DedupKey, InlineCommentSchema] = {
+            comment.dedup_key: comment for comment in self.root
+        }
+
+        return InlineCommentListSchema(root=list(results_map.values()))

ai_review/services/review/inline/service.py

@@ -0,0 +1,38 @@
+import re
+
+from pydantic import ValidationError
+
+from ai_review.libs.logger import get_logger
+from ai_review.services.review.inline.schema import InlineCommentListSchema
+
+logger = get_logger("INLINE_COMMENT_SERVICE")
+
+FIRST_JSON_ARRAY_RE = re.compile(r"\[[\s\S]*]", re.MULTILINE)
+CLEAN_JSON_BLOCK_RE = re.compile(r"```(?:json)?(.*?)```", re.DOTALL | re.IGNORECASE)
+
+
+class InlineCommentService:
+    @classmethod
+    def parse_model_output(cls, output: str) -> InlineCommentListSchema:
+        output = (output or "").strip()
+        if not output:
+            logger.warning("️LLM returned empty string for inline review")
+            return InlineCommentListSchema(root=[])
+
+        if match := CLEAN_JSON_BLOCK_RE.search(output):
+            output = match.group(1).strip()
+
+        try:
+            return InlineCommentListSchema.model_validate_json(output)
+        except ValidationError:
+            logger.warning("LLM output is not valid JSON, trying to extract first JSON array...")
+
+        if json_array_match := FIRST_JSON_ARRAY_RE.search(output):
+            try:
+                return InlineCommentListSchema.model_validate_json(json_array_match.group(0))
+            except ValidationError:
+                logger.exception("JSON array found but still invalid")
+        else:
+            logger.exception("No JSON array found in LLM output")
+
+        return InlineCommentListSchema(root=[])

ai_review/services/review/policy/service.py

@@ -0,0 +1,60 @@
+import fnmatch
+
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+
+logger = get_logger("REVIEW_POLICY_SERVICE")
+
+
+class ReviewPolicyService:
+    @classmethod
+    def should_review_file(cls, file: str) -> bool:
+        review = settings.review
+
+        for pattern in review.ignore_changes:
+            if fnmatch.fnmatch(file, pattern):
+                logger.debug(f"Skipping {file} (matched ignore: {pattern})")
+                return False
+
+        if not review.allow_changes:
+            logger.debug(f"Allowing {file} (no allow rules, passed ignore)")
+            return True
+
+        for pattern in review.allow_changes:
+            if fnmatch.fnmatch(file, pattern):
+                logger.debug(f"Allowing {file} (matched allow: {pattern})")
+                return True
+
+        logger.debug(f"Skipping {file} (did not match any allow rule)")
+        return False
+
+    @classmethod
+    def apply_for_files(cls, files: list[str]) -> list[str]:
+        allowed = [file for file in files if cls.should_review_file(file)]
+        skipped = [file for file in files if not cls.should_review_file(file)]
+
+        if skipped:
+            logger.info(f"Skipped {len(skipped)} files by policy: {skipped}")
+
+        if allowed:
+            logger.info(f"Proceeding with {len(allowed)} files after policy filter")
+
+        return allowed
+
+    @classmethod
+    def apply_for_inline_comments(cls, comments: list) -> list:
+        limit = settings.review.max_inline_comments
+        if limit and (len(comments) > limit):
+            logger.info(f"Limiting inline comments to {limit} (from {len(comments)})")
+            return comments[:limit]
+
+        return comments
+
+    @classmethod
+    def apply_for_context_comments(cls, comments: list) -> list:
+        limit = settings.review.max_context_comments
+        if limit and (len(comments) > limit):
+            logger.info(f"Limiting context comments to {limit} (from {len(comments)})")
+            return comments[:limit]
+
+        return comments

ai_review/services/review/service.py

@@ -0,0 +1,207 @@
+from typing import Literal
+
+from ai_review.config import settings
+from ai_review.libs.asynchronous.gather import bounded_gather
+from ai_review.libs.logger import get_logger
+from ai_review.services.artifacts.service import ArtifactsService
+from ai_review.services.cost.service import CostService
+from ai_review.services.diff.service import DiffService
+from ai_review.services.git.service import GitService
+from ai_review.services.llm.factory import get_llm_client
+from ai_review.services.prompt.adapter import build_prompt_context_from_mr_info
+from ai_review.services.prompt.service import PromptService
+from ai_review.services.review.inline.schema import InlineCommentListSchema
+from ai_review.services.review.inline.service import InlineCommentService
+from ai_review.services.review.policy.service import ReviewPolicyService
+from ai_review.services.review.summary.service import SummaryCommentService
+from ai_review.services.vcs.factory import get_vcs_client
+from ai_review.services.vcs.types import MRInfoSchema
+
+logger = get_logger("REVIEW_SERVICE")
+
+
+class ReviewService:
+    def __init__(self):
+        self.llm = get_llm_client()
+        self.vcs = get_vcs_client()
+        self.git = GitService()
+        self.diff = DiffService()
+        self.cost = CostService()
+        self.prompt = PromptService()
+        self.policy = ReviewPolicyService()
+        self.inline = InlineCommentService()
+        self.summary = SummaryCommentService()
+        self.artifacts = ArtifactsService()
+
+    async def ask_llm(self, prompt: str, prompt_system: str) -> str:
+        try:
+            result = await self.llm.chat(prompt, prompt_system)
+            if not result.text:
+                logger.warning(
+                    f"LLM returned an empty response (prompt length={len(prompt)} chars)"
+                )
+
+            report = self.cost.calculate(result)
+            if report:
+                logger.info(report.pretty())
+
+            await self.artifacts.save_llm_interaction(prompt, prompt_system, result.text)
+
+            return result.text
+        except Exception as error:
+            logger.exception(f"LLM request failed: {error}")
+            raise
+
+    async def has_existing_inline_discussions(self) -> bool:
+        discussions = await self.vcs.get_discussions()
+        has_discussions = any(
+            settings.review.inline_tag in note.body
+            for discussion in discussions
+            for note in discussion.notes
+        )
+        if has_discussions:
+            logger.info("Skipping inline review: AI inline discussions already exist")
+
+        return has_discussions
+
+    async def has_existing_summary_comments(self) -> bool:
+        comments = await self.vcs.get_comments()
+        has_comments = any(settings.review.summary_tag in comment.body for comment in comments)
+        if has_comments:
+            logger.info("Skipping summary review: AI summary comment already exists")
+
+        return has_comments
+
+    async def process_discussions(self, flow: Literal["inline", "context"], comments: InlineCommentListSchema) -> None:
+        results = await bounded_gather([
+            self.vcs.create_discussion(
+                file=comment.file,
+                line=comment.line,
+                message=comment.body_with_tag
+            )
+            for comment in comments.root
+        ])
+        fallbacks = [
+            self.vcs.create_comment(comment.fallback_body_with_tag)
+            for comment, result in zip(comments.root, results)
+            if isinstance(result, Exception)
+        ]
+        if fallbacks:
+            logger.warning(f"Falling back to {len(fallbacks)} general comments ({flow} review)")
+            await bounded_gather(fallbacks)
+
+    async def process_file_inline(self, file: str, mr_info: MRInfoSchema) -> None:
+        raw_diff = self.git.get_diff_for_file(mr_info.base_sha, mr_info.head_sha, file)
+        if not raw_diff.strip():
+            logger.debug(f"No diff for {file}, skipping")
+            return
+
+        rendered_file = self.diff.render_file(
+            file=file,
+            base_sha=mr_info.base_sha,
+            head_sha=mr_info.head_sha,
+            raw_diff=raw_diff,
+        )
+        prompt_context = build_prompt_context_from_mr_info(mr_info)
+        prompt = self.prompt.build_inline_request(rendered_file, prompt_context)
+        prompt_system = self.prompt.build_system_inline_request(prompt_context)
+        prompt_result = await self.ask_llm(prompt, prompt_system)
+
+        comments = self.inline.parse_model_output(prompt_result).dedupe()
+        comments.root = self.policy.apply_for_inline_comments(comments.root)
+        if not comments.root:
+            logger.info(f"No inline comments for file: {file}")
+            return
+
+        logger.info(f"Posting {len(comments.root)} inline comments to {file}")
+        await self.process_discussions(flow="inline", comments=comments)
+
+    async def run_inline_review(self) -> None:
+        if await self.has_existing_inline_discussions():
+            return
+
+        mr_info = await self.vcs.get_mr_info()
+
+        logger.info(f"Starting inline review: {len(mr_info.changed_files)} files changed")
+
+        changed_files = self.policy.apply_for_files(mr_info.changed_files)
+        await bounded_gather([
+            self.process_file_inline(changed_file, mr_info)
+            for changed_file in changed_files
+        ])
+
+    async def run_context_review(self) -> None:
+        if await self.has_existing_inline_discussions():
+            return
+
+        mr_info = await self.vcs.get_mr_info()
+        changed_files = self.policy.apply_for_files(mr_info.changed_files)
+
+        if not changed_files:
+            logger.info("No files to review for context review")
+            return
+
+        logger.info(f"Starting context inline review: {len(changed_files)} files changed")
+
+        rendered_files = self.diff.render_files(
+            git=self.git,
+            files=changed_files,
+            base_sha=mr_info.base_sha,
+            head_sha=mr_info.head_sha,
+        )
+        prompt_context = build_prompt_context_from_mr_info(mr_info)
+        prompt = self.prompt.build_context_request(rendered_files, prompt_context)
+        prompt_system = self.prompt.build_system_context_request(prompt_context)
+        prompt_result = await self.ask_llm(prompt, prompt_system)
+
+        comments = self.inline.parse_model_output(prompt_result).dedupe()
+        comments.root = self.policy.apply_for_context_comments(comments.root)
+        if not comments.root:
+            logger.info("No inline comments from context review")
+            return
+
+        logger.info(f"Posting {len(comments.root)} inline comments (context review)")
+        await self.process_discussions(flow="context", comments=comments)
+
+    async def run_summary_review(self) -> None:
+        if await self.has_existing_summary_comments():
+            return
+
+        mr_info = await self.vcs.get_mr_info()
+        changed_files = self.policy.apply_for_files(mr_info.changed_files)
+
+        if not changed_files:
+            logger.info("No files to review for summary")
+            return
+
+        logger.info(f"Starting summary review: {len(changed_files)} files changed")
+
+        rendered_files = self.diff.render_files(
+            git=self.git,
+            files=changed_files,
+            base_sha=mr_info.base_sha,
+            head_sha=mr_info.head_sha,
+        )
+        prompt_context = build_prompt_context_from_mr_info(mr_info)
+        prompt = self.prompt.build_summary_request(rendered_files, prompt_context)
+        prompt_system = self.prompt.build_system_summary_request(prompt_context)
+        prompt_result = await self.ask_llm(prompt, prompt_system)
+
+        summary = self.summary.parse_model_output(prompt_result)
+        if not summary.text.strip():
+            logger.warning("Summary LLM output was empty, skipping comment")
+            return
+
+        logger.info(f"Posting summary review comment ({len(summary.text)} chars)")
+        await self.vcs.create_comment(summary.body_with_tag)
+
+    def report_total_cost(self):
+        total_report = self.cost.aggregate()
+        if total_report:
+            logger.info(
+                "\n=== TOTAL REVIEW COST ===\n"
+                f"{total_report.pretty()}\n"
+                "========================="
+            )
+        else:
+            logger.info("No cost data collected for this review")

ai_review/services/review/summary/schema.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, field_validator
+
+from ai_review.config import settings
+
+
+class SummaryCommentSchema(BaseModel):
+    text: str
+
+    @field_validator("text")
+    def normalize_text(cls, value: str) -> str:
+        return (value or "").strip()
+
+    @property
+    def body_with_tag(self):
+        return f"{self.text}\n\n{settings.review.summary_tag}"

ai_review/services/review/summary/service.py

@@ -0,0 +1,14 @@
+from ai_review.libs.logger import get_logger
+from ai_review.services.review.summary.schema import SummaryCommentSchema
+
+logger = get_logger("SUMMARY_COMMENT_SERVICE")
+
+
+class SummaryCommentService:
+    @classmethod
+    def parse_model_output(cls, output: str) -> SummaryCommentSchema:
+        text = (output or "").strip()
+        if not text:
+            logger.warning("LLM returned empty summary")
+
+        return SummaryCommentSchema(text=text)

ai_review/services/vcs/factory.py

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

ai_review/services/vcs/gitlab/client.py

@@ -0,0 +1,152 @@
+from ai_review.clients.gitlab.client import get_gitlab_http_client
+from ai_review.clients.gitlab.mr.schema.discussions import (
+    GitLabDiscussionPositionSchema,
+    GitLabCreateMRDiscussionRequestSchema
+)
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.types import (
+    VCSClient,
+    MRUserSchema,
+    MRInfoSchema,
+    MRNoteSchema,
+    MRCommentSchema,
+    MRDiscussionSchema,
+)
+
+logger = get_logger("GITLAB_VCS_CLIENT")
+
+
+class GitLabVCSClient(VCSClient):
+    def __init__(self):
+        self.http_client = get_gitlab_http_client()
+        self.project_id = settings.vcs.pipeline.project_id
+        self.merge_request_id = settings.vcs.pipeline.merge_request_id
+
+    async def get_mr_info(self) -> MRInfoSchema:
+        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}")
+
+            return MRInfoSchema(
+                title=response.title,
+                author=MRUserSchema(
+                    name=response.author.name,
+                    username=response.author.username
+                ),
+                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
+                ],
+                assignees=[
+                    MRUserSchema(name=assignee.name, username=assignee.username)
+                    for assignee in response.assignees
+                ],
+                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"merge_request_id={self.merge_request_id}: {error}"
+            )
+            return MRInfoSchema()
+
+    async def get_comments(self) -> list[MRCommentSchema]:
+        try:
+            response = await self.http_client.mr.get_comments(
+                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}"
+            )
+
+            return [MRCommentSchema(id=comment.id, body=comment.body) for comment in response.root]
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch comments project_id={self.project_id} "
+                f"merge_request_id={self.merge_request_id}: {error}"
+            )
+            return []
+
+    async def get_discussions(self) -> list[MRDiscussionSchema]:
+        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}"
+            )
+
+            return [
+                MRDiscussionSchema(
+                    id=discussion.id,
+                    notes=[MRNoteSchema(id=note.id, body=note.body or "") for note in discussion.notes],
+                )
+                for discussion in response.root
+            ]
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch discussions project_id={self.project_id} "
+                f"merge_request_id={self.merge_request_id}: {error}"
+            )
+            return []
+
+    async def create_comment(self, message: str) -> None:
+        try:
+            logger.info(
+                f"Posting comment to merge_request_id={self.merge_request_id}: {message}",
+            )
+            await self.http_client.mr.create_comment(
+                comment=message,
+                project_id=self.project_id,
+                merge_request_id=self.merge_request_id,
+            )
+            logger.info(f"Created comment in {self.merge_request_id=}")
+        except Exception as error:
+            logger.exception(f"Failed to create comment in merge_request_id={self.merge_request_id}: {error}")
+
+    async def create_discussion(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}"
+            )
+
+            response = await self.http_client.mr.get_changes(
+                project_id=self.project_id,
+                merge_request_id=self.merge_request_id,
+            )
+
+            request = GitLabCreateMRDiscussionRequestSchema(
+                body=message,
+                position=GitLabDiscussionPositionSchema(
+                    position_type="text",
+                    base_sha=response.diff_refs.base_sha,
+                    head_sha=response.diff_refs.head_sha,
+                    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}")
+        except Exception as error:
+            logger.exception(
+                f"Failed to create discussion in merge_request_id={self.merge_request_id} "
+                f"at {file}:{line}: {error}"
+            )

ai_review/services/vcs/types.py

@@ -0,0 +1,55 @@
+from typing import Protocol
+
+from pydantic import BaseModel, Field
+
+
+class MRUserSchema(BaseModel):
+    name: str = ""
+    username: str = ""
+
+
+class MRInfoSchema(BaseModel):
+    title: str = ""
+    author: MRUserSchema = Field(default_factory=MRUserSchema)
+    labels: 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
+    body: str
+
+
+class MRDiscussionSchema(BaseModel):
+    id: str
+    notes: list[MRNoteSchema]
+
+
+class MRCommentSchema(BaseModel):
+    id: int | str
+    body: str
+
+
+class VCSClient(Protocol):
+    async def get_mr_info(self) -> MRInfoSchema:
+        ...
+
+    async def get_comments(self) -> list[MRCommentSchema]:
+        ...
+
+    async def get_discussions(self) -> list[MRDiscussionSchema]:
+        ...
+
+    async def create_comment(self, message: str) -> None:
+        ...
+
+    async def create_discussion(self, file: str, line: int, message: str) -> None:
+        ...

ai_review/tests/fixtures/git.py

@@ -0,0 +1,31 @@
+# ai_review/tests/conftest.py
+from typing import Any
+
+import pytest
+
+from ai_review.services.git.types import GitServiceProtocol
+
+
+class FakeGitService(GitServiceProtocol):
+    """Simple fake for GitService used in tests."""
+
+    def __init__(self, responses: dict[str, Any] | None = None) -> None:
+        self.responses = responses or {}
+
+    def get_diff(self, base_sha: str, head_sha: str, unified: int = 3) -> str:
+        return self.responses.get("get_diff", "")
+
+    def get_diff_for_file(self, base_sha: str, head_sha: str, file: str, unified: int = 3) -> str:
+        return self.responses.get("get_diff_for_file", "")
+
+    def get_changed_files(self, base_sha: str, head_sha: str) -> list[str]:
+        return self.responses.get("get_changed_files", [])
+
+    def get_file_at_commit(self, file_path: str, sha: str) -> str | None:
+        return self.responses.get("get_file_at_commit", None)
+
+
+@pytest.fixture
+def fake_git() -> FakeGitService:
+    """Default fake GitService with empty responses."""
+    return FakeGitService()