xai-review 0.3.0__py3-none-any.whl

ai_review/config.py

@@ -0,0 +1,62 @@
+from pydantic_settings import (
+    BaseSettings,
+    SettingsConfigDict,
+    YamlConfigSettingsSource,
+    JsonConfigSettingsSource,
+    PydanticBaseSettingsSource
+)
+
+from ai_review.libs.config.artifacts import ArtifactsConfig
+from ai_review.libs.config.base import (
+    get_env_config_file_or_default,
+    get_yaml_config_file_or_default,
+    get_json_config_file_or_default
+)
+from ai_review.libs.config.llm import LLMConfig
+from ai_review.libs.config.logger import LoggerConfig
+from ai_review.libs.config.prompt import PromptConfig
+from ai_review.libs.config.review import ReviewConfig
+from ai_review.libs.config.vcs import VCSConfig
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        extra='allow',
+
+        env_file=get_env_config_file_or_default(),
+        env_file_encoding="utf-8",
+        env_nested_delimiter="__",
+
+        yaml_file=get_yaml_config_file_or_default(),
+        yaml_file_encoding="utf-8",
+
+        json_file=get_json_config_file_or_default(),
+        json_file_encoding="utf-8"
+    )
+
+    llm: LLMConfig
+    vcs: VCSConfig
+    prompt: PromptConfig = PromptConfig()
+    review: ReviewConfig = ReviewConfig()
+    logger: LoggerConfig = LoggerConfig()
+    artifacts: ArtifactsConfig = ArtifactsConfig()
+
+    @classmethod
+    def settings_customise_sources(
+            cls,
+            settings_cls: type[BaseSettings],
+            init_settings: PydanticBaseSettingsSource,
+            env_settings: PydanticBaseSettingsSource,
+            dotenv_settings: PydanticBaseSettingsSource,
+            file_secret_settings: PydanticBaseSettingsSource,
+    ) -> tuple[PydanticBaseSettingsSource, ...]:
+        return (
+            YamlConfigSettingsSource(cls),
+            JsonConfigSettingsSource(cls),
+            env_settings,
+            dotenv_settings,
+            init_settings,
+        )
+
+
+settings = Settings()

ai_review/libs/asynchronous/gather.py

@@ -0,0 +1,14 @@
+import asyncio
+from typing import Awaitable, Iterable, TypeVar
+
+T = TypeVar("T")
+
+
+async def bounded_gather(coroutines: Iterable[Awaitable[T]], concurrency: int = 32) -> tuple[T, ...]:
+    sem = asyncio.Semaphore(concurrency)
+
+    async def wrap(coro: Awaitable[T]) -> T:
+        async with sem:
+            return await coro
+
+    return await asyncio.gather(*(wrap(coroutine) for coroutine in coroutines), return_exceptions=True)

ai_review/libs/config/artifacts.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, DirectoryPath, field_validator, Field
+
+
+class ArtifactsConfig(BaseModel):
+    llm_dir: DirectoryPath = Field(default=DirectoryPath("./artifacts/llm"), validate_default=True)
+    llm_enabled: bool = False
+
+    @field_validator('llm_dir', mode='before')
+    def validate_directories(cls, value: DirectoryPath | str) -> DirectoryPath:
+        directory = DirectoryPath(value)
+        directory.mkdir(parents=True, exist_ok=True)
+        return directory

ai_review/libs/config/base.py

@@ -0,0 +1,24 @@
+import os
+from enum import StrEnum
+
+
+class ConfigEnv(StrEnum):
+    ENV = "AI_REVIEW_CONFIG_FILE_ENV"
+    YAML = "AI_REVIEW_CONFIG_FILE_YAML"
+    JSON = "AI_REVIEW_CONFIG_FILE_JSON"
+
+
+def get_config_file_or_default(variable: str, default_filename: str) -> str:
+    return os.getenv(variable, os.path.join(os.getcwd(), default_filename))
+
+
+def get_env_config_file_or_default() -> str:
+    return get_config_file_or_default(ConfigEnv.ENV, ".env")
+
+
+def get_yaml_config_file_or_default() -> str:
+    return get_config_file_or_default(ConfigEnv.YAML, ".ai-review.yaml")
+
+
+def get_json_config_file_or_default() -> str:
+    return get_config_file_or_default(ConfigEnv.JSON, ".ai-review.json")

ai_review/libs/config/claude.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+from ai_review.libs.config.http import HTTPClientConfig
+
+
+class ClaudeMetaConfig(BaseModel):
+    model: str = "claude-3-sonnet"
+    max_tokens: int = 1200
+    temperature: float = 0.3
+
+
+class ClaudeHTTPClientConfig(HTTPClientConfig):
+    api_version: str = "2023-06-01"

ai_review/libs/config/gemini.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+from ai_review.libs.config.http import HTTPClientConfig
+
+
+class GeminiMetaConfig(BaseModel):
+    model: str = "gemini-2.0-pro"
+    max_tokens: int = 1200
+    temperature: float = 0.3
+
+
+class GeminiHTTPClientConfig(HTTPClientConfig):
+    pass

ai_review/libs/config/gitlab.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+from ai_review.libs.config.http import HTTPClientConfig
+
+
+class GitLabPipelineConfig(BaseModel):
+    project_id: str
+    merge_request_id: str
+
+
+class GitLabHTTPClientConfig(HTTPClientConfig):
+    pass

ai_review/libs/config/http.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, HttpUrl, SecretStr
+
+
+class HTTPClientConfig(BaseModel):
+    timeout: float = 120
+    api_url: HttpUrl
+    api_token: SecretStr
+
+    @property
+    def api_key(self) -> str:
+        return self.api_token.get_secret_value()
+
+    @property
+    def base_url(self) -> str:
+        return str(self.api_url)
+
+    @property
+    def bearer_token(self) -> str:
+        return self.api_token.get_secret_value()

ai_review/libs/config/llm.py

@@ -0,0 +1,61 @@
+from functools import cached_property
+from typing import Annotated, Literal
+
+import yaml
+from pydantic import BaseModel, Field, FilePath
+
+from ai_review.libs.config.claude import ClaudeHTTPClientConfig, ClaudeMetaConfig
+from ai_review.libs.config.gemini import GeminiHTTPClientConfig, GeminiMetaConfig
+from ai_review.libs.config.openai import OpenAIHTTPClientConfig, OpenAIMetaConfig
+from ai_review.libs.constants.llm_provider import LLMProvider
+from ai_review.libs.resources import load_resource
+
+
+class LLMPricingConfig(BaseModel):
+    input: float
+    output: float
+
+
+class LLMConfigBase(BaseModel):
+    provider: LLMProvider
+    pricing_file: FilePath | None = None
+
+    @cached_property
+    def pricing_file_or_default(self):
+        if self.pricing_file and self.pricing_file.exists():
+            return self.pricing_file
+
+        return load_resource(
+            package="ai_review.resources",
+            filename="pricing.yaml",
+            fallback="ai_review/resources/pricing.yaml"
+        )
+
+    def load_pricing(self) -> dict[str, LLMPricingConfig]:
+        data = self.pricing_file_or_default.read_text(encoding="utf-8")
+        raw = yaml.safe_load(data)
+        return {model: LLMPricingConfig(**values) for model, values in raw.items()}
+
+
+class OpenAILLMConfig(LLMConfigBase):
+    meta: OpenAIMetaConfig
+    provider: Literal[LLMProvider.OPENAI]
+    http_client: OpenAIHTTPClientConfig
+
+
+class GeminiLLMConfig(LLMConfigBase):
+    meta: GeminiMetaConfig
+    provider: Literal[LLMProvider.GEMINI]
+    http_client: GeminiHTTPClientConfig
+
+
+class ClaudeLLMConfig(LLMConfigBase):
+    meta: ClaudeMetaConfig
+    provider: Literal[LLMProvider.CLAUDE]
+    http_client: ClaudeHTTPClientConfig
+
+
+LLMConfig = Annotated[
+    OpenAILLMConfig | GeminiLLMConfig | ClaudeLLMConfig,
+    Field(discriminator="provider")
+]

ai_review/libs/config/logger.py

@@ -0,0 +1,17 @@
+from enum import StrEnum
+
+from pydantic import BaseModel
+
+
+class LoggerLevel(StrEnum):
+    NOTSET = "NOTSET"
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class LoggerConfig(BaseModel):
+    level: LoggerLevel = LoggerLevel.INFO
+    format: str = "{time:YYYY-MM-DD HH:mm:ss} | {level} | {extra[logger_name]} | {message}"

ai_review/libs/config/openai.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+from ai_review.libs.config.http import HTTPClientConfig
+
+
+class OpenAIMetaConfig(BaseModel):
+    model: str = "gpt-4o-mini"
+    max_tokens: int = 1200
+    temperature: float = 0.3
+
+
+class OpenAIHTTPClientConfig(HTTPClientConfig):
+    pass

ai_review/libs/config/prompt.py

@@ -0,0 +1,121 @@
+from functools import cached_property
+from pathlib import Path
+
+from pydantic import BaseModel, FilePath, Field
+
+from ai_review.libs.resources import load_resource
+
+
+class PromptConfig(BaseModel):
+    context: dict[str, str] = Field(default_factory=dict)
+    inline_prompt_files: list[FilePath] | None = None
+    context_prompt_files: list[FilePath] | None = None
+    summary_prompt_files: list[FilePath] | None = None
+    system_inline_prompt_files: list[FilePath] | None = None
+    system_context_prompt_files: list[FilePath] | None = None
+    system_summary_prompt_files: list[FilePath] | None = None
+    include_inline_system_prompts: bool = True
+    include_context_system_prompts: bool = True
+    include_summary_system_prompts: bool = True
+
+    @cached_property
+    def inline_prompt_files_or_default(self) -> list[Path]:
+        return self.inline_prompt_files or [
+            load_resource(
+                package="ai_review.prompts",
+                filename="default_inline.md",
+                fallback="ai_review/prompts/default_inline.md"
+            )
+        ]
+
+    @cached_property
+    def context_prompt_files_or_default(self) -> list[Path]:
+        return self.context_prompt_files or [
+            load_resource(
+                package="ai_review.prompts",
+                filename="default_context.md",
+                fallback="ai_review/prompts/default_context.md"
+            )
+        ]
+
+    @cached_property
+    def summary_prompt_files_or_default(self) -> list[Path]:
+        return self.summary_prompt_files or [
+            load_resource(
+                package="ai_review.prompts",
+                filename="default_summary.md",
+                fallback="ai_review/prompts/default_summary.md"
+            )
+        ]
+
+    @cached_property
+    def system_inline_prompt_files_or_default(self) -> list[Path]:
+        global_files = [
+            load_resource(
+                package="ai_review.prompts",
+                filename="default_system_inline.md",
+                fallback="ai_review/prompts/default_system_inline.md"
+            )
+        ]
+
+        if self.system_inline_prompt_files is None:
+            return global_files
+
+        if self.include_inline_system_prompts:
+            return global_files + self.system_inline_prompt_files
+
+        return self.system_inline_prompt_files
+
+    @cached_property
+    def system_context_prompt_files_or_default(self) -> list[Path]:
+        global_files = [
+            load_resource(
+                package="ai_review.prompts",
+                filename="default_system_context.md",
+                fallback="ai_review/prompts/default_system_context.md"
+            )
+        ]
+
+        if self.system_context_prompt_files is None:
+            return global_files
+
+        if self.include_context_system_prompts:
+            return global_files + self.system_context_prompt_files
+
+        return self.system_context_prompt_files
+
+    @cached_property
+    def system_summary_prompt_files_or_default(self) -> list[Path]:
+        global_files = [
+            load_resource(
+                package="ai_review.prompts",
+                filename="default_system_summary.md",
+                fallback="ai_review/prompts/default_system_summary.md"
+            )
+        ]
+
+        if self.system_summary_prompt_files is None:
+            return global_files
+
+        if self.include_summary_system_prompts:
+            return global_files + self.system_summary_prompt_files
+
+        return self.system_summary_prompt_files
+
+    def load_inline(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.inline_prompt_files_or_default]
+
+    def load_context(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.context_prompt_files_or_default]
+
+    def load_summary(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.summary_prompt_files_or_default]
+
+    def load_system_inline(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.system_inline_prompt_files_or_default]
+
+    def load_system_context(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.system_context_prompt_files_or_default]
+
+    def load_system_summary(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.system_summary_prompt_files_or_default]

ai_review/libs/config/review.py

@@ -0,0 +1,30 @@
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+class ReviewMode(StrEnum):
+    FULL_FILE_DIFF = "FULL_FILE_DIFF"
+    FULL_FILE_CURRENT = "FULL_FILE_CURRENT"
+    FULL_FILE_PREVIOUS = "FULL_FILE_PREVIOUS"
+
+    ONLY_ADDED = "ONLY_ADDED"
+    ONLY_REMOVED = "ONLY_REMOVED"
+    ADDED_AND_REMOVED = "ADDED_AND_REMOVED"
+
+    ONLY_ADDED_WITH_CONTEXT = "ONLY_ADDED_WITH_CONTEXT"
+    ONLY_REMOVED_WITH_CONTEXT = "ONLY_REMOVED_WITH_CONTEXT"
+    ADDED_AND_REMOVED_WITH_CONTEXT = "ADDED_AND_REMOVED_WITH_CONTEXT"
+
+
+class ReviewConfig(BaseModel):
+    mode: ReviewMode = ReviewMode.FULL_FILE_DIFF
+    inline_tag: str = Field(default="#ai-review-inline")
+    summary_tag: str = Field(default="#ai-review-summary")
+    context_lines: int = Field(default=10, ge=0)
+    allow_changes: list[str] = Field(default_factory=list)
+    ignore_changes: list[str] = Field(default_factory=list)
+    review_added_marker: str = " # added"
+    review_removed_marker: str = " # removed"
+    max_inline_comments: int | None = None
+    max_context_comments: int | None = None

ai_review/libs/config/vcs.py

@@ -0,0 +1,19 @@
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, Field
+
+from ai_review.libs.config.gitlab import GitLabPipelineConfig, GitLabHTTPClientConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+
+
+class VCSConfigBase(BaseModel):
+    provider: VCSProvider
+
+
+class GitLabVCSConfig(VCSConfigBase):
+    provider: Literal[VCSProvider.GITLAB]
+    pipeline: GitLabPipelineConfig
+    http_client: GitLabHTTPClientConfig
+
+
+VCSConfig = Annotated[GitLabVCSConfig, Field(discriminator="provider")]

ai_review/libs/constants/llm_provider.py

@@ -0,0 +1,7 @@
+from enum import StrEnum
+
+
+class LLMProvider(StrEnum):
+    OPENAI = "OPENAI"
+    GEMINI = "GEMINI"
+    CLAUDE = "CLAUDE"

ai_review/libs/constants/vcs_provider.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+
+class VCSProvider(StrEnum):
+    GITHUB = "GITHUB"
+    GITLAB = "GITLAB"

ai_review/libs/diff/models.py

@@ -0,0 +1,100 @@
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import List
+
+
+class FileMode(Enum):
+    DELETED = auto()
+    MODIFIED = auto()
+    NEW = auto()
+
+
+class DiffLineType(Enum):
+    ADDED = auto()
+    REMOVED = auto()
+    UNCHANGED = auto()
+
+
+@dataclass
+class DiffLine:
+    type: DiffLineType
+    number: int | None
+    content: str
+    position: int
+
+
+@dataclass
+class DiffRange:
+    start: int
+    length: int
+    lines: List[DiffLine]
+
+
+@dataclass
+class DiffHunk:
+    header: str
+    orig_range: DiffRange
+    new_range: DiffRange
+    lines: List[DiffLine]
+
+
+@dataclass
+class DiffFile:
+    header: str
+    mode: FileMode
+    orig_name: str
+    new_name: str
+    hunks: List[DiffHunk]
+
+    def added_new_lines(self) -> list[DiffLine]:
+        return [
+            line
+            for hunk in self.hunks
+            for line in hunk.new_range.lines
+            if line.type is DiffLineType.ADDED
+        ]
+
+    def removed_old_lines(self) -> list[DiffLine]:
+        return [
+            line
+            for hunk in self.hunks
+            for line in hunk.orig_range.lines
+            if line.type is DiffLineType.REMOVED
+        ]
+
+    def added_line_numbers(self) -> set[int]:
+        return {line.number for line in self.added_new_lines() if line.number is not None}
+
+    def removed_line_numbers(self) -> set[int]:
+        return {line.number for line in self.removed_old_lines() if line.number is not None}
+
+
+@dataclass
+class Diff:
+    files: List[DiffFile]
+    raw: str
+
+    def summary(self) -> str:
+        parts = []
+        for file in self.files:
+            parts.append(f"{file.mode.name} {file.new_name or file.orig_name}")
+            for hunk in file.hunks:
+                parts.append(f"  Hunk: {hunk.header} ({len(hunk.lines)} lines)")
+
+        return "\n".join(parts)
+
+    def changed_lines(self) -> dict[str, list[int]]:
+        result: dict[str, list[int]] = {}
+        for file in self.files:
+            if file.mode == FileMode.DELETED:
+                continue
+
+            result[file.new_name] = [
+                line.number for h in file.hunks for line in h.new_range.lines
+                if line.type == DiffLineType.ADDED
+            ]
+
+        return result
+
+    def changed_files(self) -> list[str]:
+        return [file.new_name for file in self.files if file.mode != FileMode.DELETED]

ai_review/libs/diff/parser.py

@@ -0,0 +1,111 @@
+import re
+
+from ai_review.libs.diff.models import (
+    Diff,
+    DiffFile,
+    DiffHunk,
+    DiffLine,
+    DiffLineType,
+    DiffRange,
+    FileMode,
+)
+from ai_review.libs.diff.tools import is_source_line, get_line_type
+
+HUNK_RE = re.compile(r"@@ -(\d+),?(\d+)? \+(\d+),?(\d+)? @@ ?(.*)?")
+OLD_FILE_PREFIX = "--- a/"
+NEW_FILE_PREFIX = "+++ b/"
+
+
+class DiffParser:
+    @classmethod
+    def parse(cls, diff_string: str) -> Diff:
+        lines = diff_string.splitlines()
+        files: list[DiffFile] = []
+
+        current_file: DiffFile | None = None
+        current_hunk: DiffHunk | None = None
+
+        added_count = removed_count = 0
+        diff_pos = 0
+
+        for raw in lines:
+            diff_pos += 1
+
+            # Начало нового файла
+            if raw.startswith("diff "):
+                current_file = DiffFile(
+                    header=raw,
+                    mode=FileMode.MODIFIED,
+                    orig_name="",
+                    new_name="",
+                    hunks=[],
+                )
+                files.append(current_file)
+                continue
+
+            # Дополняем header файла
+            if raw.startswith("index ") or raw.startswith("--- ") or raw.startswith("+++ "):
+                current_file.header += "\n" + raw
+
+            if raw.startswith(OLD_FILE_PREFIX):
+                current_file.orig_name = raw[len(OLD_FILE_PREFIX):]
+                continue
+
+            if raw.startswith(NEW_FILE_PREFIX):
+                current_file.new_name = raw[len(NEW_FILE_PREFIX):]
+                continue
+
+            if raw == "+++ /dev/null":
+                current_file.mode = FileMode.DELETED
+                continue
+
+            if raw == "--- /dev/null":
+                current_file.mode = FileMode.NEW
+                continue
+
+            if raw.startswith("@@ "):
+                match = HUNK_RE.match(raw)
+                if not match:
+                    raise ValueError(f"Invalid hunk header: {raw}")
+
+                a, b, c, d, header = match.groups()
+                orig_start, orig_len = int(a), int(b or 0)
+                new_start, new_len = int(c), int(d or 0)
+
+                current_hunk = DiffHunk(
+                    header=header or "",
+                    orig_range=DiffRange(orig_start, orig_len, []),
+                    new_range=DiffRange(new_start, new_len, []),
+                    lines=[],
+                )
+                current_file.hunks.append(current_hunk)
+
+                added_count, removed_count = new_start, orig_start
+                continue
+
+            if current_hunk and is_source_line(raw):
+                line_type = get_line_type(raw)
+                content = raw[1:]
+
+                if line_type is DiffLineType.ADDED:
+                    line = DiffLine(line_type, added_count, content, diff_pos)
+                    current_hunk.new_range.lines.append(line)
+                    current_hunk.lines.append(line)
+                    added_count += 1
+
+                elif line_type is DiffLineType.REMOVED:
+                    line = DiffLine(line_type, removed_count, content, diff_pos)
+                    current_hunk.orig_range.lines.append(line)
+                    current_hunk.lines.append(line)
+                    removed_count += 1
+
+                else:
+                    line_new = DiffLine(DiffLineType.UNCHANGED, added_count, content, diff_pos)
+                    line_old = DiffLine(DiffLineType.UNCHANGED, removed_count, content, diff_pos)
+                    current_hunk.new_range.lines.append(line_new)
+                    current_hunk.orig_range.lines.append(line_old)
+                    current_hunk.lines.append(line_new)
+                    added_count += 1
+                    removed_count += 1
+
+        return Diff(files=files, raw=diff_string)