xai-review 0.3.0__py3-none-any.whl

ai_review/libs/diff/tools.py

@@ -0,0 +1,24 @@
+from ai_review.libs.diff.models import DiffLineType
+
+
+def is_source_line(line: str) -> bool:
+    if line == r"":
+        return False
+    if not line or line.startswith("---") or line.startswith("+++"):
+        return False
+    return True
+
+
+def get_line_type(line: str) -> DiffLineType:
+    if not line:
+        raise ValueError("Empty line cannot be classified as DiffLineType")
+
+    match line[0]:
+        case "+":
+            return DiffLineType.ADDED
+        case "-":
+            return DiffLineType.REMOVED
+        case " ":
+            return DiffLineType.UNCHANGED
+        case _:
+            raise ValueError(f"Unknown diff line prefix: {line!r}")

ai_review/libs/http/client.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from httpx import AsyncClient, Response, QueryParams
+
+
+class HTTPClient:
+    def __init__(self, client: AsyncClient) -> None:
+        self.client = client
+
+    async def get(self, url: str, query: QueryParams | None = None) -> Response:
+        return await self.client.get(url=url, params=query)
+
+    async def post(self, url: str, json: Any | None = None) -> Response:
+        return await self.client.post(url=url, json=json)

ai_review/libs/http/event_hooks/base.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+from httpx import Request, Response
+
+
+class BaseEventHook(ABC):
+    @abstractmethod
+    async def request(self, request: Request) -> None:
+        ...
+
+    @abstractmethod
+    async def response(self, response: Response) -> None:
+        ...

ai_review/libs/http/event_hooks/logger.py

@@ -0,0 +1,17 @@
+from logging import Logger
+
+from httpx import Request, Response
+
+from ai_review.libs.http.event_hooks.base import BaseEventHook
+
+
+class LoggerEventHook(BaseEventHook):
+    def __init__(self, logger: Logger):
+        self.logger = logger
+
+    async def request(self, request: Request):
+        self.logger.info(f"{request.method} {request.url} - Waiting for response")
+
+    async def response(self, response: Response):
+        request = response.request
+        self.logger.info(f"{request.method} {request.url} - Status {response.status_code}")

ai_review/libs/http/handlers.py

@@ -0,0 +1,34 @@
+from functools import wraps
+from typing import Callable, Coroutine, Any
+
+from httpx import Response, HTTPStatusError
+
+APIFunc = Callable[..., Coroutine[Any, Any, Response]]
+
+
+class HTTPClientError(Exception):
+    def __init__(self, client: str, details: str, status_code: int):
+        self.details = f'[{client}]: {details}'
+        self.status_code = status_code
+
+        super().__init__(f"[{client}] {status_code}: {details}")
+
+
+def handle_http_error(client: str, exception: type[HTTPClientError]):
+    def wrapper(func: APIFunc):
+        @wraps(func)
+        async def inner(*args, **kwargs):
+            response = await func(*args, **kwargs)
+
+            try:
+                return response.raise_for_status()
+            except HTTPStatusError as error:
+                raise exception(
+                    client=client,
+                    details=error.response.text or f'{client} returned error',
+                    status_code=error.response.status_code
+                ) from error
+
+        return inner
+
+    return wrapper

ai_review/libs/http/transports/retry.py

@@ -0,0 +1,34 @@
+import asyncio
+from http import HTTPStatus
+
+from httpx import Request, Response, AsyncBaseTransport
+
+
+class RetryTransport(AsyncBaseTransport):
+    def __init__(
+            self,
+            transport: AsyncBaseTransport,
+            max_retries: int = 5,
+            retry_delay: float = 0.5,
+            retry_status_codes: tuple[HTTPStatus, ...] = (
+                    HTTPStatus.BAD_GATEWAY,
+                    HTTPStatus.GATEWAY_TIMEOUT,
+                    HTTPStatus.SERVICE_UNAVAILABLE,
+                    HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
+    ):
+        self.transport = transport
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+        self.retry_status_codes = retry_status_codes
+
+    async def handle_async_request(self, request: Request) -> Response:
+        response: Response | None = None
+        for _ in range(self.max_retries):
+            response = await self.transport.handle_async_request(request)
+            if response.status_code not in self.retry_status_codes:
+                return response
+
+            await asyncio.sleep(self.retry_delay)
+
+        return response

ai_review/libs/logger.py

@@ -0,0 +1,19 @@
+from typing import TYPE_CHECKING
+
+from loguru import logger
+
+from ai_review.config import settings
+
+if TYPE_CHECKING:
+    from loguru import Logger
+
+logger.remove()
+logger.add(
+    sink=lambda msg: print(msg, end=""),
+    format=settings.logger.format,
+    level=settings.logger.level,
+)
+
+
+def get_logger(name: str) -> "Logger":
+    return logger.bind(logger_name=name)

ai_review/libs/resources.py

@@ -0,0 +1,24 @@
+import importlib.metadata
+import importlib.resources
+import os
+import pathlib
+import shutil
+import tempfile
+
+
+def load_resource(package: str, filename: str, fallback: str | None = None) -> pathlib.Path:
+    try:
+        traversable = importlib.resources.files(package) / filename
+        if isinstance(traversable, pathlib.Path):
+            return traversable
+
+        tmp_dir = pathlib.Path(tempfile.gettempdir())
+        tmp_file = tmp_dir / filename
+        with traversable.open("rb") as src, tmp_file.open("wb") as dst:
+            shutil.copyfileobj(src, dst)
+        return tmp_file
+    except importlib.metadata.PackageNotFoundError:
+        if fallback:
+            return pathlib.Path(os.path.join(os.getcwd(), fallback))
+
+        raise

ai_review/prompts/default_context.md

@@ -0,0 +1,14 @@
+Focus on code correctness, clarity, and maintainability across the entire set of changes.  
+Add inline comments for:
+
+- potential bugs or logical errors,
+- inconsistent or confusing naming across files,
+- redundant or duplicate code,
+- improvements for readability or best practices.
+
+Guidelines:
+
+- Analyze all provided files together, but output comments in the same format as inline review.
+- If there are many issues, prioritize the most important ones (maximum 50 comments).
+- Keep comments short, actionable, and relevant.
+- Do not comment on unchanged code or stylistic preferences unless they clearly affect maintainability.

ai_review/prompts/default_inline.md

@@ -0,0 +1,8 @@
+Focus on code correctness, clarity, and maintainability.  
+Add inline comments for:
+
+- potential bugs or logical errors,
+- confusing or overly complex code,
+- improvements for readability or best practices.
+
+Keep comments short, actionable, and relevant.  

ai_review/prompts/default_summary.md

@@ -0,0 +1,3 @@
+- Write a short summary of the overall review.
+- Mention what was done well and highlight the most important issues or improvements.
+- Keep it clear and concise (2–4 sentences).  

ai_review/prompts/default_system_context.md

@@ -0,0 +1,27 @@
+Return ONLY a valid JSON array of inline review comments.
+
+Format:
+
+```json
+[
+  {
+    "file": "<relative_file_path>",
+    "line": <line_number>,
+    "message": "<short review message explaining the issue or suggestion>",
+    "suggestion": "<replacement code block, without markdown, or null if not applicable>"
+  }
+]
+```
+
+Rules:
+
+- Analyze all provided files together, but output comments in the same format as inline review.
+- Prioritize the most important issues if there are many (maximum 50 comments).
+- "file" must exactly match the file path in the diff.
+- "line" must be an integer from the new version of the file.
+- "message" must be a short, clear, and actionable explanation (1 sentence).
+- "suggestion" must contain ONLY the code to replace the line(s), without markdown or comments.
+    - Use correct indentation from the file.
+    - If no concrete replacement is appropriate, set "suggestion" to null.
+- Do not include anything outside the JSON array.
+- If no issues are found, return [].

ai_review/prompts/default_system_inline.md

@@ -0,0 +1,25 @@
+Return ONLY a valid JSON array of inline review comments.
+
+Format:
+
+```json
+[
+  {
+    "file": "<relative_file_path>",
+    "line": <line_number>,
+    "message": "<short review message explaining the issue or suggestion>",
+    "suggestion": "<replacement code block, without markdown, or null if not applicable>"
+  }
+]
+```
+
+Rules:
+
+- "file" must exactly match the file path in the diff.
+- "line" must be an integer from the new version of the file.
+- "message" must be a short, clear, and actionable explanation (1 sentence).
+- "suggestion" must contain ONLY the code to replace the line(s), without markdown or comments.
+    - Use correct indentation from the file.
+    - If no concrete replacement is appropriate, set "suggestion" to null.
+- Do not include anything outside the JSON array.
+- If no issues are found, return [].

ai_review/prompts/default_system_summary.md

@@ -0,0 +1,7 @@
+Return ONLY a plain text summary of the code review.
+
+Rules:
+
+- Output must be plain text, no JSON, no markdown.
+- Keep it concise but informative (1–4 sentences).
+- If there are no issues, return exactly: No issues found.

ai_review/resources/pricing.yaml

@@ -0,0 +1,55 @@
+gpt-4o-mini:
+  input: 0.15e-6
+  output: 0.60e-6
+
+gpt-4o:
+  input: 5.00e-6
+  output: 15.00e-6
+
+gpt-4.1-mini:
+  input: 0.15e-6
+  output: 0.60e-6
+
+gpt-4.1:
+  input: 5.00e-6
+  output: 15.00e-6
+
+gpt-3.5-turbo:
+  input: 0.50e-6
+  output: 1.50e-6
+
+gemini-2.5-flash-lite:
+  input: 0.10e-6
+  output: 0.40e-6
+
+gemini-2.0-flash-lite:
+  input: 0.019e-6
+  output: 0.1e-6
+
+gemini-2.0-pro:
+  input: 0.125e-6
+  output: 0.375e-6
+
+gemini-2.5-pro:
+  input: 1.25e-6
+  output: 10.00e-6
+
+gemini-2.5-pro-long-context:
+  input: 2.50e-6
+  output: 15.00e-6
+
+claude-3.5-sonnet:
+  input: 3.00e-6
+  output: 15.00e-6
+
+claude-3-opus:
+  input: 15.00e-6
+  output: 75.00e-6
+
+claude-3-sonnet:
+  input: 3.00e-6
+  output: 15.00e-6
+
+claude-3-haiku:
+  input: 0.25e-6
+  output: 1.25e-6

ai_review/services/artifacts/schema.py

@@ -0,0 +1,11 @@
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class LLMArtifactSchema(BaseModel):
+    id: str
+    prompt: str
+    response: str | None = None
+    timestamp: str = Field(default_factory=datetime.utcnow().isoformat)
+    prompt_system: str

ai_review/services/artifacts/service.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+
+import aiofiles
+
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.artifacts.schema import LLMArtifactSchema
+from ai_review.services.artifacts.tools import make_artifact_id
+
+logger = get_logger("ARTIFACTS_SERVICE")
+
+
+class ArtifactsService:
+    @classmethod
+    async def save_llm_interaction(cls, prompt: str, prompt_system: str, response: str | None = None) -> str | None:
+        if not settings.artifacts.llm_enabled:
+            logger.debug("Artifacts for LLM saving is disabled, skipping")
+            return None
+
+        artifact_id = make_artifact_id(prompt)
+        logger.info(f"Creating LLM interaction with id={artifact_id}")
+
+        file = settings.artifacts.llm_dir / f"{artifact_id}.json"
+        record = LLMArtifactSchema(
+            id=artifact_id,
+            prompt=prompt,
+            response=response,
+            prompt_system=prompt_system
+        )
+
+        try:
+            await cls.save_artifact(file, record.model_dump_json(indent=2), kind="llm_interaction")
+        except Exception as error:
+            logger.exception(f"Failed to save LLM interaction {artifact_id}: {error}")
+
+        return artifact_id
+
+    @classmethod
+    async def save_artifact(cls, file: Path, content: str, kind: str = "artifact") -> Path | None:
+        try:
+            async with aiofiles.open(file, "w", encoding="utf-8") as aiofile:
+                await aiofile.write(content)
+            logger.debug(f"Saved {kind} → {file}")
+            return file
+        except Exception as error:
+            logger.exception(f"Failed to save {kind} {file.stem}: {error}")
+            return None

ai_review/services/artifacts/tools.py

@@ -0,0 +1,8 @@
+import hashlib
+from datetime import datetime
+
+
+def make_artifact_id(text: str) -> str:
+    sha = hashlib.sha1(text.encode()).hexdigest()[:8]
+    ts = datetime.utcnow().strftime("%Y.%m.%d_%H-%M-%S")
+    return f"{ts}_{sha}"

ai_review/services/cost/schema.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel
+
+
+class CostReportSchema(BaseModel):
+    model: str
+    prompt_tokens: int
+    completion_tokens: int
+    input_cost: float
+    output_cost: float
+    total_cost: float
+
+    @property
+    def prompt_percent(self) -> float:
+        return (self.input_cost / self.total_cost * 100) if self.total_cost else 0.0
+
+    @property
+    def completion_percent(self) -> float:
+        return (self.output_cost / self.total_cost * 100) if self.total_cost else 0.0
+
+    @property
+    def pretty_total_line(self) -> str:
+        return f"- {'Total:':<20} {'':>7}   {self.total_cost:12.6f} USD"
+
+    @property
+    def pretty_prompt_line(self) -> str:
+        return (
+            f"- {'Prompt tokens:':<20} {self.prompt_tokens:>7} → "
+            f"{self.input_cost:12.6f} USD ({self.prompt_percent:.1f}%)"
+        )
+
+    @property
+    def pretty_completion_line(self) -> str:
+        return (
+            f"- {'Completion tokens:':<20} {self.completion_tokens:>7} → "
+            f"{self.output_cost:12.6f} USD ({self.completion_percent:.1f}%)"
+        )
+
+    def pretty(self) -> str:
+        return (
+            f"\n💰 Estimated Cost for `{self.model}`\n"
+            f"{self.pretty_prompt_line}\n"
+            f"{self.pretty_completion_line}\n"
+            f"{self.pretty_total_line}\n"
+        )

ai_review/services/cost/service.py

@@ -0,0 +1,58 @@
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.cost.schema import CostReportSchema
+from ai_review.services.llm.types import ChatResultSchema
+
+logger = get_logger("COST_SERVICE")
+
+
+class CostService:
+    def __init__(self):
+        self.pricing = settings.llm.load_pricing()
+        self.reports: list[CostReportSchema] = []
+
+    def calculate(self, result: ChatResultSchema) -> CostReportSchema | None:
+        if (result.prompt_tokens is None) or (result.completion_tokens is None):
+            return None
+
+        model = settings.llm.meta.model
+        pricing = self.pricing.get(model)
+        if not pricing:
+            logger.warning(f"No pricing found for {model=}, skipping cost calculation")
+            return None
+
+        input_cost = result.prompt_tokens * pricing.input
+        output_cost = result.completion_tokens * pricing.output
+        total_cost = input_cost + output_cost
+
+        report = CostReportSchema(
+            model=settings.llm.meta.model,
+            total_cost=total_cost,
+            input_cost=input_cost,
+            output_cost=output_cost,
+            prompt_tokens=result.prompt_tokens,
+            completion_tokens=result.completion_tokens,
+        )
+
+        self.reports.append(report)
+        return report
+
+    def aggregate(self) -> CostReportSchema | None:
+        if not self.reports:
+            return None
+
+        model = self.reports[0].model
+        total_cost = sum(report.total_cost for report in self.reports)
+        input_cost = sum(report.input_cost for report in self.reports)
+        output_cost = sum(report.output_cost for report in self.reports)
+        prompt_tokens = sum(report.prompt_tokens for report in self.reports)
+        completion_tokens = sum(report.completion_tokens for report in self.reports)
+
+        return CostReportSchema(
+            model=model,
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            input_cost=input_cost,
+            output_cost=output_cost,
+            total_cost=total_cost,
+        )