xai-review 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

ai_review/libs/config/prompt.py

@@ -6,104 +6,123 @@ from pydantic import BaseModel, FilePath, Field
 from ai_review.libs.resources import load_resource
 
 
+def resolve_prompt_files(files: list[FilePath] | None, default_file: str) -> list[Path]:
+    return files or [
+        load_resource(
+            package="ai_review.prompts",
+            filename=default_file,
+            fallback=f"ai_review/prompts/{default_file}"
+        )
+    ]
+
+
+def resolve_system_prompt_files(files: list[FilePath] | None, include: bool, default_file: str) -> list[Path]:
+    global_files = [
+        load_resource(
+            package="ai_review.prompts",
+            filename=default_file,
+            fallback=f"ai_review/prompts/{default_file}"
+        )
+    ]
+
+    if files is None:
+        return global_files
+
+    if include:
+        return global_files + files
+
+    return files
+
+
 class PromptConfig(BaseModel):
     context: dict[str, str] = Field(default_factory=dict)
     normalize_prompts: bool = True
     context_placeholder: str = "<<{value}>>"
+
+    # --- Prompts ---
     inline_prompt_files: list[FilePath] | None = None
     context_prompt_files: list[FilePath] | None = None
     summary_prompt_files: list[FilePath] | None = None
+    inline_reply_prompt_files: list[FilePath] | None = None
+    summary_reply_prompt_files: list[FilePath] | None = None
+
+    # --- System Prompts ---
     system_inline_prompt_files: list[FilePath] | None = None
     system_context_prompt_files: list[FilePath] | None = None
     system_summary_prompt_files: list[FilePath] | None = None
+    system_inline_reply_prompt_files: list[FilePath] | None = None
+    system_summary_reply_prompt_files: list[FilePath] | None = None
+
+    # --- Include System Prompts ---
     include_inline_system_prompts: bool = True
     include_context_system_prompts: bool = True
     include_summary_system_prompts: bool = True
+    include_inline_reply_system_prompts: bool = True
+    include_summary_reply_system_prompts: bool = True
 
+    # --- Prompts ---
     @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"
-            )
-        ]
+        return resolve_prompt_files(self.inline_prompt_files, "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"
-            )
-        ]
+        return resolve_prompt_files(self.context_prompt_files, "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"
-            )
-        ]
+        return resolve_prompt_files(self.summary_prompt_files, "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
+    def inline_reply_prompt_files_or_default(self) -> list[Path]:
+        return resolve_prompt_files(self.inline_reply_prompt_files, "default_inline_reply.md")
 
-        if self.include_inline_system_prompts:
-            return global_files + self.system_inline_prompt_files
+    @cached_property
+    def summary_reply_prompt_files_or_default(self) -> list[Path]:
+        return resolve_prompt_files(self.summary_reply_prompt_files, "default_summary_reply.md")
 
-        return self.system_inline_prompt_files
+    # --- System Prompts ---
+    @cached_property
+    def system_inline_prompt_files_or_default(self) -> list[Path]:
+        return resolve_system_prompt_files(
+            files=self.system_inline_prompt_files,
+            include=self.include_inline_system_prompts,
+            default_file="default_system_inline.md"
+        )
 
     @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
+        return resolve_system_prompt_files(
+            files=self.system_context_prompt_files,
+            include=self.include_context_system_prompts,
+            default_file="default_system_context.md"
+        )
 
     @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 resolve_system_prompt_files(
+            files=self.system_summary_prompt_files,
+            include=self.include_summary_system_prompts,
+            default_file="default_system_summary.md"
+        )
 
-        return self.system_summary_prompt_files
+    @cached_property
+    def system_inline_reply_prompt_files_or_default(self) -> list[Path]:
+        return resolve_system_prompt_files(
+            files=self.system_inline_reply_prompt_files,
+            include=self.include_inline_reply_system_prompts,
+            default_file="default_system_inline_reply.md"
+        )
 
+    @cached_property
+    def system_summary_reply_prompt_files_or_default(self) -> list[Path]:
+        return resolve_system_prompt_files(
+            files=self.system_summary_reply_prompt_files,
+            include=self.include_summary_reply_system_prompts,
+            default_file="default_system_summary_reply.md"
+        )
+
+    # --- Load Prompts ---
     def load_inline(self) -> list[str]:
         return [file.read_text(encoding="utf-8") for file in self.inline_prompt_files_or_default]
 
@@ -113,6 +132,13 @@ class PromptConfig(BaseModel):
     def load_summary(self) -> list[str]:
         return [file.read_text(encoding="utf-8") for file in self.summary_prompt_files_or_default]
 
+    def load_inline_reply(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.inline_reply_prompt_files_or_default]
+
+    def load_summary_reply(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.summary_reply_prompt_files_or_default]
+
+    # --- Load System Prompts ---
     def load_system_inline(self) -> list[str]:
         return [file.read_text(encoding="utf-8") for file in self.system_inline_prompt_files_or_default]
 
@@ -121,3 +147,9 @@ class PromptConfig(BaseModel):
 
     def load_system_summary(self) -> list[str]:
         return [file.read_text(encoding="utf-8") for file in self.system_summary_prompt_files_or_default]
+
+    def load_system_inline_reply(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.system_inline_reply_prompt_files_or_default]
+
+    def load_system_summary_reply(self) -> list[str]:
+        return [file.read_text(encoding="utf-8") for file in self.system_summary_reply_prompt_files_or_default]

ai_review/libs/config/review.py

@@ -20,7 +20,9 @@ class ReviewMode(StrEnum):
 class ReviewConfig(BaseModel):
     mode: ReviewMode = ReviewMode.FULL_FILE_DIFF
     inline_tag: str = Field(default="#ai-review-inline")
+    inline_reply_tag: str = Field(default="#ai-review-inline-reply")
     summary_tag: str = Field(default="#ai-review-summary")
+    summary_reply_tag: str = Field(default="#ai-review-summary-reply")
     context_lines: int = Field(default=10, ge=0)
     allow_changes: list[str] = Field(default_factory=list)
     ignore_changes: list[str] = Field(default_factory=list)

ai_review/libs/llm/output_json_parser.py

@@ -0,0 +1,60 @@
+import re
+from typing import TypeVar, Generic, Type
+
+from pydantic import BaseModel, ValidationError
+
+from ai_review.libs.json import sanitize_json_string
+from ai_review.libs.logger import get_logger
+
+logger = get_logger("LLM_JSON_PARSER")
+
+T = TypeVar("T", bound=BaseModel)
+
+CLEAN_JSON_BLOCK_RE = re.compile(r"```(?:json)?(.*?)```", re.DOTALL | re.IGNORECASE)
+
+
+class LLMOutputJSONParser(Generic[T]):
+    """Reusable JSON parser for LLM responses."""
+
+    def __init__(self, model: Type[T]):
+        self.model = model
+        self.model_name = self.model.__name__
+
+    def try_parse(self, raw: str) -> T | None:
+        logger.debug(f"[{self.model_name}] Attempting JSON parse (len={len(raw)})")
+
+        try:
+            return self.model.model_validate_json(raw)
+        except ValidationError as error:
+            logger.warning(f"[{self.model_name}] Raw JSON parse failed: {error}")
+            cleaned = sanitize_json_string(raw)
+
+            if cleaned != raw:
+                logger.debug(f"[{self.model_name}] Sanitized JSON differs, retrying parse...")
+                try:
+                    return self.model.model_validate_json(cleaned)
+                except ValidationError as error:
+                    logger.warning(f"[{self.model_name}] Sanitized JSON still invalid: {error}")
+                    return None
+            else:
+                logger.debug(f"[{self.model_name}] Sanitized JSON identical — skipping retry")
+                return None
+
+    def parse_output(self, output: str) -> T | None:
+        output = (output or "").strip()
+        if not output:
+            logger.warning(f"[{self.model_name}] Empty LLM output")
+            return None
+
+        logger.debug(f"[{self.model_name}] Parsing output (len={len(output)})")
+
+        if match := CLEAN_JSON_BLOCK_RE.search(output):
+            logger.debug(f"[{self.model_name}] Found fenced JSON block, extracting...")
+            output = match.group(1).strip()
+
+        if parsed := self.try_parse(output):
+            logger.info(f"[{self.model_name}] Successfully parsed")
+            return parsed
+
+        logger.error(f"[{self.model_name}] No valid JSON found in output")
+        return None

ai_review/prompts/default_inline_reply.md

@@ -0,0 +1,10 @@
+You are an AI assistant replying to a specific inline code review comment.
+
+Use the conversation (`## Conversation`) and code diff (`## Diff`) to continue the discussion constructively.
+
+Guidelines:
+
+- Focus only on the latest comment and relevant code context.
+- Keep your tone concise, professional, and technical (1–2 sentences).
+- If a code change is needed, include it in "suggestion" — provide only the replacement code.
+- If no further action or clarification is required, output exactly: No reply.

ai_review/prompts/default_summary_reply.md

@@ -0,0 +1,14 @@
+You are an AI assistant participating in a summary code review discussion.
+
+Use the previous conversation (`## Conversation`) and code changes (`## Changes`) to continue the discussion
+constructively.
+
+Guidelines:
+
+- Act as a **technical reviewer**, not the code author.
+- Keep your tone concise, professional, and focused (1–3 sentences).
+- Address the latest user comment directly, providing clarification, reasoning, or an actionable suggestion.
+- If the comment contains a request or implies an action (e.g. adding tests, refactoring, or improving validation),
+  provide a clear recommendation or short illustrative code snippet.
+- Avoid greetings, acknowledgements, or repeating earlier feedback.
+- If no reply is needed, write exactly: `No reply`.

ai_review/prompts/default_system_inline_reply.md

@@ -0,0 +1,31 @@
+You are an AI assistant participating in a code review discussion.
+
+Return ONLY a valid JSON object representing a single inline reply to the current comment thread.
+
+Format:
+
+```json
+{
+  "message": "<short reply message to the comment thread>",
+  "suggestion": "<replacement code block without markdown, or null if not applicable>"
+}
+```
+
+Guidelines:
+
+- Output must be exactly one JSON object, not an array or text block.
+- "message" — required, non-empty, short (1–2 sentences), professional, and focused on the specific comment.
+- "suggestion" — optional:
+    - If suggesting a fix or refactor, provide only the replacement code (no markdown, no explanations).
+    - Maintain indentation and style consistent with the surrounding diff.
+    - If no code change is appropriate, use null.
+- Do not quote previous comments or restate context.
+- Never include any extra text outside the JSON object.
+- If no meaningful reply is needed, return:
+
+```json
+{
+  "message": "No reply.",
+  "suggestion": null
+}
+```

ai_review/prompts/default_system_summary_reply.md

@@ -0,0 +1,13 @@
+You are an AI assistant participating in a code review discussion.
+
+Your role:
+
+- Act as a **technical reviewer**, not the code author.
+- Focus on clarity, correctness, and completeness of the code or proposal.
+- Keep your tone concise, professional, and factual (1–3 sentences).
+- Reply only to the latest message in the discussion thread.
+- When the user requests or implies an action (e.g. adding tests, refactoring, improving performance), provide a
+  **specific, actionable suggestion** or short code snippet that addresses it.
+- Avoid greetings, acknowledgements, or filler phrases.
+- Do not summarize past discussion history.
+- If no reply is needed, output exactly: `No reply`.

ai_review/services/artifacts/schema.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 
 from pydantic import BaseModel, Field
 
@@ -7,5 +7,5 @@ class LLMArtifactSchema(BaseModel):
     id: str
     prompt: str
     response: str | None = None
-    timestamp: str = Field(default_factory=datetime.utcnow().isoformat)
+    timestamp: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
     prompt_system: str

ai_review/services/hook/constants.py

@@ -15,6 +15,12 @@ class HookType(StrEnum):
     ON_SUMMARY_REVIEW_START = "ON_SUMMARY_REVIEW_START"
     ON_SUMMARY_REVIEW_COMPLETE = "ON_SUMMARY_REVIEW_COMPLETE"
 
+    ON_INLINE_REPLY_REVIEW_START = "ON_INLINE_REPLY_REVIEW_START"
+    ON_INLINE_REPLY_REVIEW_COMPLETE = "ON_INLINE_REPLY_REVIEW_COMPLETE"
+
+    ON_SUMMARY_REPLY_REVIEW_START = "ON_SUMMARY_REPLY_REVIEW_START"
+    ON_SUMMARY_REPLY_REVIEW_COMPLETE = "ON_SUMMARY_REPLY_REVIEW_COMPLETE"
+
     ON_INLINE_COMMENT_START = "ON_INLINE_COMMENT_START"
     ON_INLINE_COMMENT_ERROR = "ON_INLINE_COMMENT_ERROR"
     ON_INLINE_COMMENT_COMPLETE = "ON_INLINE_COMMENT_COMPLETE"
@@ -22,3 +28,11 @@ class HookType(StrEnum):
     ON_SUMMARY_COMMENT_START = "ON_SUMMARY_COMMENT_START"
     ON_SUMMARY_COMMENT_ERROR = "ON_SUMMARY_COMMENT_ERROR"
     ON_SUMMARY_COMMENT_COMPLETE = "ON_SUMMARY_COMMENT_COMPLETE"
+
+    ON_INLINE_COMMENT_REPLY_START = "ON_INLINE_COMMENT_REPLY_START"
+    ON_INLINE_COMMENT_REPLY_ERROR = "ON_INLINE_COMMENT_REPLY_ERROR"
+    ON_INLINE_COMMENT_REPLY_COMPLETE = "ON_INLINE_COMMENT_REPLY_COMPLETE"
+
+    ON_SUMMARY_COMMENT_REPLY_START = "ON_SUMMARY_COMMENT_REPLY_START"
+    ON_SUMMARY_COMMENT_REPLY_ERROR = "ON_SUMMARY_COMMENT_REPLY_ERROR"
+    ON_SUMMARY_COMMENT_REPLY_COMPLETE = "ON_SUMMARY_COMMENT_REPLY_COMPLETE"

ai_review/services/hook/service.py

@@ -19,16 +19,33 @@ from ai_review.services.hook.types import (
     # --- Summary Review ---
     SummaryReviewStartHookFunc,
     SummaryReviewCompleteHookFunc,
+    # --- Inline Reply Review ---
+    InlineReplyReviewStartHookFunc,
+    InlineReplyReviewCompleteHookFunc,
+    # --- Summary Reply Review ---
+    SummaryReplyReviewStartHookFunc,
+    SummaryReplyReviewCompleteHookFunc,
     # --- Inline Comment ---
     InlineCommentStartHookFunc,
     InlineCommentErrorHookFunc,
     InlineCommentCompleteHookFunc,
     # --- Summary Comment ---
     SummaryCommentStartHookFunc,
-    SummaryCommentCompleteHookFunc
+    SummaryCommentErrorHookFunc,
+    SummaryCommentCompleteHookFunc,
+    # --- Inline Reply Comment ---
+    InlineCommentReplyStartHookFunc,
+    InlineCommentReplyErrorHookFunc,
+    InlineCommentReplyCompleteHookFunc,
+    # --- Summary Reply Comment ---
+    SummaryCommentReplyStartHookFunc,
+    SummaryCommentReplyErrorHookFunc,
+    SummaryCommentReplyCompleteHookFunc
 )
-from ai_review.services.review.inline.schema import InlineCommentSchema
-from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.inline.schema import InlineCommentSchema
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
 
 logger = get_logger("HOOK_SERVICE")
 
@@ -117,6 +134,36 @@ class HookService:
     async def emit_summary_review_complete(self, report: CostReportSchema | None):
         await self.emit(HookType.ON_SUMMARY_REVIEW_COMPLETE, report=report)
 
+    # --- Inline Reply Review ---
+    def on_inline_reply_review_start(self, func: InlineReplyReviewStartHookFunc):
+        self.inject_hook(HookType.ON_INLINE_REPLY_REVIEW_START, func)
+        return func
+
+    def on_inline_reply_review_complete(self, func: InlineReplyReviewCompleteHookFunc):
+        self.inject_hook(HookType.ON_INLINE_REPLY_REVIEW_COMPLETE, func)
+        return func
+
+    async def emit_inline_reply_review_start(self):
+        await self.emit(HookType.ON_INLINE_REPLY_REVIEW_START)
+
+    async def emit_inline_reply_review_complete(self, report: CostReportSchema | None):
+        await self.emit(HookType.ON_INLINE_REPLY_REVIEW_COMPLETE, report=report)
+
+    # --- Summary Reply Review ---
+    def on_summary_reply_review_start(self, func: SummaryReplyReviewStartHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_REPLY_REVIEW_START, func)
+        return func
+
+    def on_summary_reply_review_complete(self, func: SummaryReplyReviewCompleteHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_REPLY_REVIEW_COMPLETE, func)
+        return func
+
+    async def emit_summary_reply_review_start(self):
+        await self.emit(HookType.ON_SUMMARY_REPLY_REVIEW_START)
+
+    async def emit_summary_reply_review_complete(self, report: CostReportSchema | None):
+        await self.emit(HookType.ON_SUMMARY_REPLY_REVIEW_COMPLETE, report=report)
+
     # --- Inline Comment ---
     def on_inline_comment_start(self, func: InlineCommentStartHookFunc):
         self.inject_hook(HookType.ON_INLINE_COMMENT_START, func)
@@ -144,7 +191,7 @@ class HookService:
         self.inject_hook(HookType.ON_SUMMARY_COMMENT_START, func)
         return func
 
-    def on_summary_comment_error(self, func: InlineCommentErrorHookFunc):
+    def on_summary_comment_error(self, func: SummaryCommentErrorHookFunc):
         self.inject_hook(HookType.ON_SUMMARY_COMMENT_ERROR, func)
         return func
 
@@ -160,3 +207,47 @@ class HookService:
 
     async def emit_summary_comment_complete(self, comment: SummaryCommentSchema):
         await self.emit(HookType.ON_SUMMARY_COMMENT_COMPLETE, comment=comment)
+
+    # --- Inline Reply Comment ---
+    def on_inline_comment_reply_start(self, func: InlineCommentReplyStartHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_REPLY_START, func)
+        return func
+
+    def on_inline_comment_reply_error(self, func: InlineCommentReplyErrorHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_REPLY_ERROR, func)
+        return func
+
+    def on_inline_comment_reply_complete(self, func: InlineCommentReplyCompleteHookFunc):
+        self.inject_hook(HookType.ON_INLINE_COMMENT_REPLY_COMPLETE, func)
+        return func
+
+    async def emit_inline_comment_reply_start(self, comment: InlineCommentReplySchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_REPLY_START, comment=comment)
+
+    async def emit_inline_comment_reply_error(self, comment: InlineCommentReplySchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_REPLY_ERROR, comment=comment)
+
+    async def emit_inline_comment_reply_complete(self, comment: InlineCommentReplySchema):
+        await self.emit(HookType.ON_INLINE_COMMENT_REPLY_COMPLETE, comment=comment)
+
+    # --- Inline Reply Comment ---
+    def on_summary_comment_reply_start(self, func: SummaryCommentReplyStartHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_REPLY_START, func)
+        return func
+
+    def on_summary_comment_reply_error(self, func: SummaryCommentReplyErrorHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_REPLY_ERROR, func)
+        return func
+
+    def on_summary_comment_reply_complete(self, func: SummaryCommentReplyCompleteHookFunc):
+        self.inject_hook(HookType.ON_SUMMARY_COMMENT_REPLY_COMPLETE, func)
+        return func
+
+    async def emit_summary_comment_reply_start(self, comment: SummaryCommentReplySchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_REPLY_START, comment=comment)
+
+    async def emit_summary_comment_reply_error(self, comment: SummaryCommentReplySchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_REPLY_ERROR, comment=comment)
+
+    async def emit_summary_comment_reply_complete(self, comment: SummaryCommentReplySchema):
+        await self.emit(HookType.ON_SUMMARY_COMMENT_REPLY_COMPLETE, comment=comment)

ai_review/services/hook/types.py

@@ -1,8 +1,10 @@
 from typing import Callable, Awaitable
 
 from ai_review.services.cost.schema import CostReportSchema
-from ai_review.services.review.inline.schema import InlineCommentSchema
-from ai_review.services.review.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.inline.schema import InlineCommentSchema
+from ai_review.services.review.internal.inline_reply.schema import InlineCommentReplySchema
+from ai_review.services.review.internal.summary.schema import SummaryCommentSchema
+from ai_review.services.review.internal.summary_reply.schema import SummaryCommentReplySchema
 
 HookFunc = Callable[..., Awaitable[None]]
 
@@ -19,6 +21,12 @@ ContextReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[No
 SummaryReviewStartHookFunc = Callable[..., Awaitable[None]]
 SummaryReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
 
+InlineReplyReviewStartHookFunc = Callable[..., Awaitable[None]]
+InlineReplyReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
+
+SummaryReplyReviewStartHookFunc = Callable[..., Awaitable[None]]
+SummaryReplyReviewCompleteHookFunc = Callable[[CostReportSchema | None], Awaitable[None]]
+
 InlineCommentStartHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
 InlineCommentErrorHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
 InlineCommentCompleteHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
@@ -26,3 +34,11 @@ InlineCommentCompleteHookFunc = Callable[[InlineCommentSchema], Awaitable[None]]
 SummaryCommentStartHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]
 SummaryCommentErrorHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]
 SummaryCommentCompleteHookFunc = Callable[[SummaryCommentSchema], Awaitable[None]]
+
+InlineCommentReplyStartHookFunc = Callable[[InlineCommentReplySchema], Awaitable[None]]
+InlineCommentReplyErrorHookFunc = Callable[[InlineCommentReplySchema], Awaitable[None]]
+InlineCommentReplyCompleteHookFunc = Callable[[InlineCommentReplySchema], Awaitable[None]]
+
+SummaryCommentReplyStartHookFunc = Callable[[SummaryCommentReplySchema], Awaitable[None]]
+SummaryCommentReplyErrorHookFunc = Callable[[SummaryCommentReplySchema], Awaitable[None]]
+SummaryCommentReplyCompleteHookFunc = Callable[[SummaryCommentReplySchema], Awaitable[None]]

ai_review/services/prompt/adapter.py

@@ -2,7 +2,7 @@ from ai_review.services.prompt.schema import PromptContextSchema
 from ai_review.services.vcs.types import ReviewInfoSchema
 
 
-def build_prompt_context_from_mr_info(review: ReviewInfoSchema) -> PromptContextSchema:
+def build_prompt_context_from_review_info(review: ReviewInfoSchema) -> PromptContextSchema:
     return PromptContextSchema(
         review_title=review.title,
         review_description=review.description,

ai_review/services/prompt/service.py

@@ -1,8 +1,9 @@
 from ai_review.config import settings
 from ai_review.services.diff.schema import DiffFileSchema
 from ai_review.services.prompt.schema import PromptContextSchema
-from ai_review.services.prompt.tools import normalize_prompt, format_file
+from ai_review.services.prompt.tools import normalize_prompt, format_file, format_thread, format_files
 from ai_review.services.prompt.types import PromptServiceProtocol
+from ai_review.services.vcs.types import ReviewThreadSchema
 
 
 class PromptService(PromptServiceProtocol):
@@ -28,7 +29,7 @@ class PromptService(PromptServiceProtocol):
     @classmethod
     def build_summary_request(cls, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
         prompt = cls.prepare_prompt(settings.prompt.load_summary(), context)
-        changes = "\n\n".join(map(format_file, diffs))
+        changes = format_files(diffs)
         return (
             f"{prompt}\n\n"
             f"## Changes\n\n"
@@ -38,13 +39,50 @@ class PromptService(PromptServiceProtocol):
     @classmethod
     def build_context_request(cls, diffs: list[DiffFileSchema], context: PromptContextSchema) -> str:
         prompt = cls.prepare_prompt(settings.prompt.load_context(), context)
-        changes = "\n\n".join(map(format_file, diffs))
+        changes = format_files(diffs)
         return (
             f"{prompt}\n\n"
             f"## Diff\n\n"
             f"{changes}\n"
         )
 
+    @classmethod
+    def build_inline_reply_request(
+            cls,
+            diff: DiffFileSchema,
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        prompt = cls.prepare_prompt(settings.prompt.load_inline_reply(), context)
+        conversation = format_thread(thread)
+
+        return (
+            f"{prompt}\n\n"
+            f"## Conversation\n\n"
+            f"{conversation}\n\n"
+            f"## Diff\n\n"
+            f"{format_file(diff)}"
+        )
+
+    @classmethod
+    def build_summary_reply_request(
+            cls,
+            diffs: list[DiffFileSchema],
+            thread: ReviewThreadSchema,
+            context: PromptContextSchema
+    ) -> str:
+        prompt = cls.prepare_prompt(settings.prompt.load_summary_reply(), context)
+        changes = format_files(diffs)
+        conversation = format_thread(thread)
+
+        return (
+            f"{prompt}\n\n"
+            f"## Conversation\n\n"
+            f"{conversation}\n\n"
+            f"## Changes\n\n"
+            f"{changes}"
+        )
+
     @classmethod
     def build_system_inline_request(cls, context: PromptContextSchema) -> str:
         return cls.prepare_prompt(settings.prompt.load_system_inline(), context)
@@ -56,3 +94,11 @@ class PromptService(PromptServiceProtocol):
     @classmethod
     def build_system_summary_request(cls, context: PromptContextSchema) -> str:
         return cls.prepare_prompt(settings.prompt.load_system_summary(), context)
+
+    @classmethod
+    def build_system_inline_reply_request(cls, context: PromptContextSchema) -> str:
+        return cls.prepare_prompt(settings.prompt.load_system_inline_reply(), context)
+
+    @classmethod
+    def build_system_summary_reply_request(cls, context: PromptContextSchema) -> str:
+        return cls.prepare_prompt(settings.prompt.load_system_summary_reply(), context)