README update

Update README.md

CONFIGURATION.md

@@ -9,6 +9,7 @@ You can select your git_provider with the flag `git_provider` in the `config` se
 You can enable/disable the different PR Reviewer abilities with the following flags (`pr_reviewer` section):
 ```
 require_focused_review=true
+require_score_review=true
 require_tests_review=true
 require_security_review=true
 ```

README.md

@@ -2,9 +2,9 @@
 
 <div align="center">
 
-<img src="./pics/logo-dark.png#gh-dark-mode-only" width="250"/>
-<img src="./pics/logo-light.png#gh-light-mode-only" width="250"/>
-
+<img src="./pics/logo-dark.png#gh-dark-mode-only" width="330"/>
+<img src="./pics/logo-light.png#gh-light-mode-only" width="330"/><br/>
+Making pull-requests less painful with an AI agent
 </div>
 
 [![GitHub license](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://github.com/Codium-ai/pr-agent/blob/main/LICENSE)
@@ -12,11 +12,11 @@
 </div>
 <div style="text-align:left;">
 
-CodiumAI `PR-Agent` is an open-source tool aiming to help developers review PRs faster and more efficiently. It automatically analyzes the PR and can provide several types of feedback:
+CodiumAI `PR-Agent` is an open-source tool aiming to help developers review pull-requests faster and more efficiently. It automatically analyzes the pull-request and can provide several types of feedback:
 
-**Auto-Description**: Automatically generating PR description - name, type, summary, and code walkthrough.
+**Auto-Description**: Automatically generating PR description - title, type, summary, code walkthrough and PR labels.
 \
-**PR Review**: Feedback about the PR main theme, type, relevant tests, security issues, focused PR, and various suggestions for the PR content.
+**PR Review**: Adjustable feedback about the PR main theme, type, relevant tests, security issues, focus, score, and various suggestions for the PR content.
 \
 **Question Answering**: Answering free-text questions about the PR.
 \
@@ -50,9 +50,10 @@ CodiumAI `PR-Agent` is an open-source tool aiming to help developers review PRs
 </div>
 <div align="left">
 
-- [Live demo](#live-demo)
+
 - [Overview](#overview)
-- [Quickstart](#quickstart)
+- [Try it now](#try-it-now)
+- [Installation](#installation)
 - [Usage and tools](#usage-and-tools)
 - [Configuration](./CONFIGURATION.md)
 - [How it works](#how-it-works)
@@ -60,15 +61,7 @@ CodiumAI `PR-Agent` is an open-source tool aiming to help developers review PRs
 - [Similar projects](#similar-projects)
 </div>
 
-## Live demo
 
-Experience GPT-4 powered PR review on your public GitHub repository with our hosted PR-Agent. To try it, just mention `@CodiumAI-Agent` and add the desired command in any PR comment! The agent will generate a response based on your command.
-
-![Review generation process](https://codium.ai/images/demo.gif)
-
-To set up your own PR-Agent, see the [Quickstart](#Quickstart) section
-
----
 ## Overview
 `PR-Agent` offers extensive pull request functionalities across various git providers:
 |       |                                             | GitHub | Gitlab | Bitbucket |
@@ -87,8 +80,9 @@ To set up your own PR-Agent, see the [Quickstart](#Quickstart) section
 | CORE  | PR compression                              |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:       |
 |       | Repo language prioritization                |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:       |
 |       | Adaptive and token-aware<br />file patch fitting |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:       |
+|       | Incremental PR Review |   :white_check_mark:    |      |         |
 
-Examples for invoking the different tools via the [CLI](#quickstart):
+Examples for invoking the different tools via the CLI:
 - **Review**:       python cli.py --pr-url=<pr_url>  review
 - **Describe**:     python cli.py --pr-url=<pr_url>  describe
 - **Improve**:      python cli.py --pr-url=<pr_url>  improve
@@ -99,18 +93,24 @@ Examples for invoking the different tools via the [CLI](#quickstart):
 
 In the [configuration](./CONFIGURATION.md) file you can select your git provider (GitHub, Gitlab, Bitbucket), and further configure the different tools.
 
-## Quickstart
+## Try it now
+
+Try GPT-4 powered PR-Agent on your public GitHub repository for free. Just mention `@CodiumAI-Agent` and add the desired command in any PR comment! The agent will generate a response based on your command.
+
+![Review generation process](https://codium.ai/images/demo.gif)
+
+To set up your own PR-Agent, see the [Installation](#installation) section
+
+---
+
+## Installation
 
 To get started with PR-Agent quickly, you first need to acquire two tokens:
 
 1. An OpenAI key from [here](https://platform.openai.com/), with access to GPT-4.
 2. A GitHub personal access token (classic) with the repo scope.
 
-There are several ways to use PR-Agent. Let's start with the simplest one:
-
-
-## Install
-Here are several ways to install and run PR-Agent:
+There are several ways to use PR-Agent:
 
 - [Method 1: Use Docker image (no installation required)](INSTALL.md#method-1-use-docker-image-no-installation-required)
 - [Method 2: Run as a GitHub Action](INSTALL.md#method-2-run-as-a-github-action)
@@ -128,7 +128,7 @@ Here are several ways to install and run PR-Agent:
 - The "PR Q&A" tool answers free-text questions about the PR.
 - The "PR Description" tool automatically sets the PR Title and body.
 - The "PR Code Suggestion" tool provide inline code suggestions for the PR that can be applied and committed.
-- The "PR Reflect and Review" tool first initiates a dialog with the user and asks them to reflect on the PR, and then provides a review.
+- The "PR Reflect and Review" tool initiates a dialog with the user, asks them to reflect on the PR, and then provides a more focused review.
 
 ## How it works
 
@@ -138,9 +138,9 @@ Check out the [PR Compression strategy](./PR_COMPRESSION.md) page for more detai
 
 ## Roadmap
 
-- [ ] Support open-source models, as a replacement for openai models. (Note - a minimal requirement for each open-source model is to have 8k+ context, and good support for generating json as an output)
+- [ ] Support open-source models, as a replacement for OpenAI models. (Note - a minimal requirement for each open-source model is to have 8k+ context, and good support for generating JSON as an output)
 - [x] Support other Git providers, such as Gitlab and Bitbucket.
-- [ ] Develop additional logics for handling large PRs, and compressing git patches
+- [ ] Develop additional logic for handling large PRs, and compressing git patches
 - [ ] Add additional context to the prompt. For example, repo (or relevant files) summarization, with tools such a [ctags](https://github.com/universal-ctags/ctags)
 - [ ] Adding more tools. Possible directions:
   - [x] PR description

pr_agent/agent/pr_agent.py

@@ -13,23 +13,20 @@ class PRAgent:
         pass
 
     async def handle_request(self, pr_url, request) -> bool:
-        if any(cmd in request for cmd in ["/answer"]):
+        action, *args = request.strip().split()
+        if any(cmd == action for cmd in ["/answer"]):
             await PRReviewer(pr_url, is_answer=True).review()
-        elif any(cmd in request for cmd in ["/review", "/review_pr", "/reflect_and_review"]):
+        elif any(cmd == action for cmd in ["/review", "/review_pr", "/reflect_and_review"]):
             if settings.pr_reviewer.ask_and_reflect or "/reflect_and_review" in request:
                 await PRInformationFromUser(pr_url).generate_questions()
             else:
-                await PRReviewer(pr_url).review()
-        elif any(cmd in request for cmd in ["/describe", "/describe_pr"]):
+                await PRReviewer(pr_url, args=args).review()
+        elif any(cmd == action for cmd in ["/describe", "/describe_pr"]):
             await PRDescription(pr_url).describe()
-        elif any(cmd in request for cmd in ["/improve", "/improve_code"]):
+        elif any(cmd == action for cmd in ["/improve", "/improve_code"]):
             await PRCodeSuggestions(pr_url).suggest()
-        elif any(cmd in request for cmd in ["/ask", "/ask_question"]):
-            pattern = r'(/ask|/ask_question)\s*(.*)'
-            matches = re.findall(pattern, request, re.IGNORECASE)
-            if matches:
-                question = matches[0][1]
-                await PRQuestions(pr_url, question).answer()
+        elif any(cmd == action for cmd in ["/ask", "/ask_question"]):
+            await PRQuestions(pr_url, args).answer()
         else:
             return False
 

pr_agent/algo/ai_handler.py

@@ -9,7 +9,17 @@ from pr_agent.config_loader import settings
 OPENAI_RETRIES=2
 
 class AiHandler:
+    """
+    This class handles interactions with the OpenAI API for chat completions.
+    It initializes the API key and other settings from a configuration file,
+    and provides a method for performing chat completions using the OpenAI ChatCompletion API.
+    """
+
     def __init__(self):
+        """
+        Initializes the OpenAI API key and other settings from a configuration file.
+        Raises a ValueError if the OpenAI key is missing.
+        """
         try:
             openai.api_key = settings.openai.key
             if settings.get("OPENAI.ORG", None):
@@ -27,6 +37,25 @@ class AiHandler:
     @retry(exceptions=(APIError, Timeout, TryAgain, AttributeError),
            tries=OPENAI_RETRIES, delay=2, backoff=2, jitter=(1, 3))
     async def chat_completion(self, model: str, temperature: float, system: str, user: str):
+        """
+        Performs a chat completion using the OpenAI ChatCompletion API.
+        Retries in case of API errors or timeouts.
+        
+        Args:
+            model (str): The model to use for chat completion.
+            temperature (float): The temperature parameter for chat completion.
+            system (str): The system message for chat completion.
+            user (str): The user message for chat completion.
+        
+        Returns:
+            tuple: A tuple containing the response and finish reason from the API.
+        
+        Raises:
+            TryAgain: If the API response is empty or there are no choices in the response.
+            APIError: If there is an error during OpenAI inference.
+            Timeout: If there is a timeout during OpenAI inference.
+            TryAgain: If there is an attribute error during OpenAI inference.
+        """
         try:
             response = await openai.ChatCompletion.acreate(
                             model=model,
@@ -44,4 +73,4 @@ class AiHandler:
             raise TryAgain
         resp = response.choices[0]['message']['content']
         finish_reason = response.choices[0].finish_reason
-        return resp, finish_reason
+        return resp, finish_reason

pr_agent/algo/git_patch_processing.py

@@ -8,7 +8,15 @@ from pr_agent.config_loader import settings
 
 def extend_patch(original_file_str, patch_str, num_lines) -> str:
     """
-    Extends the patch to include 'num_lines' more surrounding lines
+    Extends the given patch to include a specified number of surrounding lines.
+    
+    Args:
+        original_file_str (str): The original file to which the patch will be applied.
+        patch_str (str): The patch to be applied to the original file.
+        num_lines (int): The number of surrounding lines to include in the extended patch.
+        
+    Returns:
+        str: The extended patch string.
     """
     if not patch_str or num_lines == 0:
         return patch_str
@@ -61,6 +69,14 @@ def extend_patch(original_file_str, patch_str, num_lines) -> str:
 
 
 def omit_deletion_hunks(patch_lines) -> str:
+    """
+    Omit deletion hunks from the patch and return the modified patch.
+    Args:
+    - patch_lines: a list of strings representing the lines of the patch
+    Returns:
+    - A string representing the modified patch with deletion hunks omitted
+    """
+
     temp_hunk = []
     added_patched = []
     add_hunk = False
@@ -93,7 +109,20 @@ def omit_deletion_hunks(patch_lines) -> str:
 def handle_patch_deletions(patch: str, original_file_content_str: str,
                            new_file_content_str: str, file_name: str) -> str:
     """
-    Handle entire file or deletion patches
+    Handle entire file or deletion patches.
+
+    This function takes a patch, original file content, new file content, and file name as input.
+    It handles entire file or deletion patches and returns the modified patch with deletion hunks omitted.
+
+    Args:
+        patch (str): The patch to be handled.
+        original_file_content_str (str): The original content of the file.
+        new_file_content_str (str): The new content of the file.
+        file_name (str): The name of the file.
+
+    Returns:
+        str: The modified patch with deletion hunks omitted.
+
     """
     if not new_file_content_str:
         # logic for handling deleted files - don't show patch, just show that the file was deleted
@@ -111,20 +140,26 @@ def handle_patch_deletions(patch: str, original_file_content_str: str,
 
 
 def convert_to_hunks_with_lines_numbers(patch: str, file) -> str:
-    # toDO: (maybe remove '-' and '+' from the beginning of the line)
     """
-    ## src/file.ts
+    Convert a given patch string into a string with line numbers for each hunk, indicating the new and old content of the file.
+
+    Args:
+        patch (str): The patch string to be converted.
+        file: An object containing the filename of the file being patched.
+
+    Returns:
+        str: A string with line numbers for each hunk, indicating the new and old content of the file.
+
+    example output:
+## src/file.ts
 --new hunk--
 881        line1
 882        line2
 883        line3
-884        line4
-885        line6
-886        line7
-887 +      line8
-888 +      line9
-889        line10
-890        line11
+887 +      line4
+888 +      line5
+889        line6
+890        line7
 ...
 --old hunk--
         line1
@@ -134,8 +169,8 @@ def convert_to_hunks_with_lines_numbers(patch: str, file) -> str:
         line5
         line6
            ...
-
     """
+    
     patch_with_lines_str = f"## {file.filename}\n"
     import re
     patch_lines = patch.splitlines()

pr_agent/algo/pr_processing.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
-import difflib
 import logging
-from typing import Any, Tuple, Union
+from typing import Tuple, Union
 
 from pr_agent.algo.git_patch_processing import convert_to_hunks_with_lines_numbers, extend_patch, handle_patch_deletions
 from pr_agent.algo.language_handler import sort_files_by_main_languages
 from pr_agent.algo.token_handler import TokenHandler
+from pr_agent.algo.utils import load_large_diff
 from pr_agent.config_loader import settings
-from pr_agent.git_providers import GithubProvider
+from pr_agent.git_providers.git_provider import GitProvider
+
 
 DELETED_FILES_ = "Deleted files:\n"
 
@@ -19,12 +20,21 @@ OUTPUT_BUFFER_TOKENS_HARD_THRESHOLD = 600
 PATCH_EXTRA_LINES = 3
 
 
-def get_pr_diff(git_provider: Union[GithubProvider, Any], token_handler: TokenHandler,
+def get_pr_diff(git_provider: GitProvider, token_handler: TokenHandler,
                 add_line_numbers_to_hunks: bool = False, disable_extra_lines: bool =False) -> str:
     """
-    Returns a string with the diff of the PR.
-    If needed, apply diff minimization techniques to reduce the number of tokens
+    Returns a string with the diff of the pull request, applying diff minimization techniques if needed.
+
+    Args:
+        git_provider (GitProvider): An object of the GitProvider class representing the Git provider used for the pull request.
+        token_handler (TokenHandler): An object of the TokenHandler class used for handling tokens in the context of the pull request.
+        add_line_numbers_to_hunks (bool, optional): A boolean indicating whether to add line numbers to the hunks in the diff. Defaults to False.
+        disable_extra_lines (bool, optional): A boolean indicating whether to disable the extension of each patch with extra lines of context. Defaults to False.
+
+    Returns:
+        str: A string with the diff of the pull request, applying diff minimization techniques if needed.
     """
+
     if disable_extra_lines:
         global PATCH_EXTRA_LINES
         PATCH_EXTRA_LINES = 0
@@ -60,7 +70,16 @@ def pr_generate_extended_diff(pr_languages: list, token_handler: TokenHandler,
                               add_line_numbers_to_hunks: bool) -> \
         Tuple[list, int]:
     """
-    Generate a standard diff string, with patch extension
+    Generate a standard diff string with patch extension, while counting the number of tokens used and applying diff minimization techniques if needed.
+
+    Args:
+    - pr_languages: A list of dictionaries representing the languages used in the pull request and their corresponding files.
+    - token_handler: An object of the TokenHandler class used for handling tokens in the context of the pull request.
+    - add_line_numbers_to_hunks: A boolean indicating whether to add line numbers to the hunks in the diff.
+
+    Returns:
+    - patches_extended: A list of extended patches for each file in the pull request.
+    - total_tokens: The total number of tokens used in the extended patches.
     """
     total_tokens = token_handler.prompt_tokens  # initial tokens
     patches_extended = []
@@ -93,12 +112,26 @@ def pr_generate_extended_diff(pr_languages: list, token_handler: TokenHandler,
 
 def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler,
                                 convert_hunks_to_line_numbers: bool) -> Tuple[list, list, list]:
-    # Apply Diff Minimization techniques to reduce the number of tokens:
-    # 0. Start from the largest diff patch to smaller ones
-    # 1. Don't use extend context lines around diff
-    # 2. Minimize deleted files
-    # 3. Minimize deleted hunks
-    # 4. Minimize all remaining files when you reach token limit
+    """
+    Generate a compressed diff string for a pull request, using diff minimization techniques to reduce the number of tokens used.
+    Args:
+        top_langs (list): A list of dictionaries representing the languages used in the pull request and their corresponding files.
+        token_handler (TokenHandler): An object of the TokenHandler class used for handling tokens in the context of the pull request.
+        convert_hunks_to_line_numbers (bool): A boolean indicating whether to convert hunks to line numbers in the diff.
+    Returns:
+        Tuple[list, list, list]: A tuple containing the following lists:
+            - patches: A list of compressed diff patches for each file in the pull request.
+            - modified_files_list: A list of file names that were skipped due to large patch size.
+            - deleted_files_list: A list of file names that were deleted in the pull request.
+
+    Minimization techniques to reduce the number of tokens:
+    0. Start from the largest diff patch to smaller ones
+    1. Don't use extend context lines around diff
+    2. Minimize deleted files
+    3. Minimize deleted hunks
+    4. Minimize all remaining files when you reach token limit
+    """
+    
 
     patches = []
     modified_files_list = []
@@ -163,14 +196,3 @@ def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler,
     return patches, modified_files_list, deleted_files_list
 
 
-def load_large_diff(file, new_file_content_str: str, original_file_content_str: str, patch: str) -> str:
-    if not patch:  # to Do - also add condition for file extension
-        try:
-            diff = difflib.unified_diff(original_file_content_str.splitlines(keepends=True),
-                                        new_file_content_str.splitlines(keepends=True))
-            if settings.config.verbosity_level >= 2:
-                logging.warning(f"File was modified, but no patch was found. Manually creating patch: {file.filename}.")
-            patch = ''.join(diff)
-        except Exception:
-            pass
-    return patch

pr_agent/algo/token_handler.py

@@ -6,12 +6,43 @@ from pr_agent.config_loader import settings
 
 
 class TokenHandler:
+    """
+    A class for handling tokens in the context of a pull request.
+
+    Attributes:
+    - encoder: An object of the encoding_for_model class from the tiktoken module. Used to encode strings and count the number of tokens in them.
+    - limit: The maximum number of tokens allowed for the given model, as defined in the MAX_TOKENS dictionary in the pr_agent.algo module.
+    - prompt_tokens: The number of tokens in the system and user strings, as calculated by the _get_system_user_tokens method.
+    """
+
     def __init__(self, pr, vars: dict, system, user):
+        """
+        Initializes the TokenHandler object.
+
+        Args:
+        - pr: The pull request object.
+        - vars: A dictionary of variables.
+        - system: The system string.
+        - user: The user string.
+        """
         self.encoder = encoding_for_model(settings.config.model)
         self.limit = MAX_TOKENS[settings.config.model]
         self.prompt_tokens = self._get_system_user_tokens(pr, self.encoder, vars, system, user)
 
     def _get_system_user_tokens(self, pr, encoder, vars: dict, system, user):
+        """
+        Calculates the number of tokens in the system and user strings.
+
+        Args:
+        - pr: The pull request object.
+        - encoder: An object of the encoding_for_model class from the tiktoken module.
+        - vars: A dictionary of variables.
+        - system: The system string.
+        - user: The user string.
+
+        Returns:
+        The sum of the number of tokens in the system and user strings.
+        """
         environment = Environment(undefined=StrictUndefined)
         system_prompt = environment.from_string(system).render(vars)
         user_prompt = environment.from_string(user).render(vars)
@@ -21,4 +52,13 @@ class TokenHandler:
         return system_prompt_tokens + user_prompt_tokens
 
     def count_tokens(self, patch: str) -> int:
+        """
+        Counts the number of tokens in a given patch string.
+
+        Args:
+        - patch: The patch string.
+
+        Returns:
+        The number of tokens in the patch string.
+        """
         return len(self.encoder.encode(patch, disallowed_special=()))

pr_agent/algo/utils.py

@@ -1,24 +1,36 @@
 from __future__ import annotations
 
+import difflib
+from datetime import datetime
 import json
 import logging
 import re
 import textwrap
 
+from pr_agent.config_loader import settings
+
 
 def convert_to_markdown(output_data: dict) -> str:
+    """
+    Convert a dictionary of data into markdown format.
+    Args:
+        output_data (dict): A dictionary containing data to be converted to markdown format.
+    Returns:
+        str: The markdown formatted text generated from the input dictionary.
+    """    
     markdown_text = ""
 
     emojis = {
         "Main theme": "🎯",
         "Type of PR": "📌",
+        "Score": "🏅",
         "Relevant tests added": "🧪",
         "Unrelated changes": "⚠️",
         "Focused PR": "✨",
         "Security concerns": "🔒",
         "General PR suggestions": "💡",
         "Insights from user's answers": "📝",
-        "Code suggestions": "🤖"
+        "Code suggestions": "🤖",
     }
 
     for key, value in output_data.items():
@@ -30,7 +42,7 @@ def convert_to_markdown(output_data: dict) -> str:
         elif isinstance(value, list):
             if key.lower() == 'code suggestions':
                 markdown_text += "\n"  # just looks nicer with additional line breaks
-            emoji = emojis.get(key, "‣")  # Use a dash if no emoji is found for the key
+            emoji = emojis.get(key, "")
             markdown_text += f"- {emoji} **{key}:**\n\n"
             for item in value:
                 if isinstance(item, dict) and key.lower() == 'code suggestions':
@@ -38,12 +50,21 @@ def convert_to_markdown(output_data: dict) -> str:
                 elif item:
                     markdown_text += f"  - {item}\n"
         elif value != 'n/a':
-            emoji = emojis.get(key, "‣")  # Use a dash if no emoji is found for the key
+            emoji = emojis.get(key, "")
             markdown_text += f"- {emoji} **{key}:** {value}\n"
     return markdown_text
 
 
 def parse_code_suggestion(code_suggestions: dict) -> str:
+    """
+    Convert a dictionary of data into markdown format.
+
+    Args:
+        code_suggestions (dict): A dictionary containing data to be converted to markdown format.
+
+    Returns:
+        str: A string containing the markdown formatted text generated from the input dictionary.
+    """
     markdown_text = ""
     for sub_key, sub_value in code_suggestions.items():
         if isinstance(sub_value, dict):  # "code example"
@@ -63,18 +84,41 @@ def parse_code_suggestion(code_suggestions: dict) -> str:
 
 
 def try_fix_json(review, max_iter=10, code_suggestions=False):
+    """
+    Fix broken or incomplete JSON messages and return the parsed JSON data.
+
+    Args:
+    - review: A string containing the JSON message to be fixed.
+    - max_iter: An integer representing the maximum number of iterations to try and fix the JSON message.
+    - code_suggestions: A boolean indicating whether to try and fix JSON messages with code suggestions.
+
+    Returns:
+    - data: A dictionary containing the parsed JSON data.
+
+    The function attempts to fix broken or incomplete JSON messages by parsing until the last valid code suggestion.
+    If the JSON message ends with a closing bracket, the function calls the fix_json_escape_char function to fix the message.
+    If code_suggestions is True and the JSON message contains code suggestions, the function tries to fix the JSON message by parsing until the last valid code suggestion.
+    The function uses regular expressions to find the last occurrence of "}," with any number of whitespaces or newlines.
+    It tries to parse the JSON message with the closing bracket and checks if it is valid.
+    If the JSON message is valid, the parsed JSON data is returned.
+    If the JSON message is not valid, the last code suggestion is removed and the process is repeated until a valid JSON message is obtained or the maximum number of iterations is reached.
+    If a valid JSON message is not obtained, an error is logged and an empty dictionary is returned.
+    """
+
     if review.endswith("}"):
         return fix_json_escape_char(review)
-    # Try to fix JSON if it is broken/incomplete: parse until the last valid code suggestion
+
     data = {}
     if code_suggestions:
         closing_bracket = "]}"
     else:
         closing_bracket = "]}}"
+
     if review.rfind("'Code suggestions': [") > 0 or review.rfind('"Code suggestions": [') > 0:
         last_code_suggestion_ind = [m.end() for m in re.finditer(r"\}\s*,", review)][-1] - 1
         valid_json = False
         iter_count = 0
+
         while last_code_suggestion_ind > 0 and not valid_json and iter_count < max_iter:
             try:
                 data = json.loads(review[:last_code_suggestion_ind] + closing_bracket)
@@ -82,16 +126,30 @@ def try_fix_json(review, max_iter=10, code_suggestions=False):
                 review = review[:last_code_suggestion_ind].strip() + closing_bracket
             except json.decoder.JSONDecodeError:
                 review = review[:last_code_suggestion_ind]
-                # Use regular expression to find the last occurrence of "}," with any number of whitespaces or newlines
                 last_code_suggestion_ind = [m.end() for m in re.finditer(r"\}\s*,", review)][-1] - 1
                 iter_count += 1
+
         if not valid_json:
             logging.error("Unable to decode JSON response from AI")
             data = {}
+
     return data
 
 
 def fix_json_escape_char(json_message=None):
+    """
+    Fix broken or incomplete JSON messages and return the parsed JSON data.
+
+    Args:
+        json_message (str): A string containing the JSON message to be fixed.
+
+    Returns:
+        dict: A dictionary containing the parsed JSON data.
+
+    Raises:
+        None
+
+    """    
     try:
         result = json.loads(json_message)
     except Exception as e:
@@ -103,3 +161,53 @@ def fix_json_escape_char(json_message=None):
         new_message = ''.join(json_message)
         return fix_json_escape_char(json_message=new_message)
     return result
+
+
+def convert_str_to_datetime(date_str):
+    """
+    Convert a string representation of a date and time into a datetime object.
+
+    Args:
+        date_str (str): A string representation of a date and time in the format '%a, %d %b %Y %H:%M:%S %Z'
+
+    Returns:
+        datetime: A datetime object representing the input date and time.
+
+    Example:
+        >>> convert_str_to_datetime('Mon, 01 Jan 2022 12:00:00 UTC')
+        datetime.datetime(2022, 1, 1, 12, 0, 0)
+    """    
+    datetime_format = '%a, %d %b %Y %H:%M:%S %Z'
+    return datetime.strptime(date_str, datetime_format)
+
+
+def load_large_diff(file, new_file_content_str: str, original_file_content_str: str, patch: str) -> str:
+    """
+    Generate a patch for a modified file by comparing the original content of the file with the new content provided as input.
+
+    Args:
+        file: The file object for which the patch needs to be generated.
+        new_file_content_str: The new content of the file as a string.
+        original_file_content_str: The original content of the file as a string.
+        patch: An optional patch string that can be provided as input.
+
+    Returns:
+        The generated or provided patch string.
+
+    Raises:
+        None.
+
+    Additional Information:
+        - If 'patch' is not provided as input, the function generates a patch using the 'difflib' library and returns it as output.
+        - If the 'settings.config.verbosity_level' is greater than or equal to 2, a warning message is logged indicating that the file was modified but no patch was found, and a patch is manually created.
+    """
+    if not patch:  # to Do - also add condition for file extension
+        try:
+            diff = difflib.unified_diff(original_file_content_str.splitlines(keepends=True),
+                                        new_file_content_str.splitlines(keepends=True))
+            if settings.config.verbosity_level >= 2:
+                logging.warning(f"File was modified, but no patch was found. Manually creating patch: {file.filename}.")
+            patch = ''.join(diff)
+        except Exception:
+            pass
+    return patch

pr_agent/cli.py

@@ -39,13 +39,12 @@ reflect - Ask the PR author questions about the PR.
     logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
     command = args.command.lower()
     if command in ['ask', 'ask_question']:
-        question = ' '.join(args.rest).strip()
-        if len(question) == 0:
+        if len(args.rest) == 0:
             print("Please specify a question")
             parser.print_help()
             return
-        print(f"Question: {question} about PR {args.pr_url}")
-        reviewer = PRQuestions(args.pr_url, question)
+        print(f"Question: {' '.join(args.rest)} about PR {args.pr_url}")
+        reviewer = PRQuestions(args.pr_url, args.rest)
         asyncio.run(reviewer.answer())
     elif command in ['describe', 'describe_pr']:
         print(f"PR description: {args.pr_url}")
@@ -57,7 +56,7 @@ reflect - Ask the PR author questions about the PR.
         asyncio.run(reviewer.suggest())
     elif command in ['review', 'review_pr']:
         print(f"Reviewing PR: {args.pr_url}")
-        reviewer = PRReviewer(args.pr_url, cli_mode=True)
+        reviewer = PRReviewer(args.pr_url, cli_mode=True, args=args.rest)
         asyncio.run(reviewer.review())
     elif command in ['reflect']:
         print(f"Asking the PR author questions: {args.pr_url}")

pr_agent/git_providers/bitbucket_provider.py

@@ -11,7 +11,7 @@ from .git_provider import FilePatchInfo
 
 
 class BitbucketProvider:
-    def __init__(self, pr_url: Optional[str] = None):
+    def __init__(self, pr_url: Optional[str] = None, incremental: Optional[bool] = False):
         s = requests.Session()
         s.headers['Authorization'] = f'Bearer {settings.get("BITBUCKET.BEARER_TOKEN", None)}'
         self.bitbucket_client = Cloud(session=s)
@@ -22,6 +22,7 @@ class BitbucketProvider:
         self.pr_num = None
         self.pr = None
         self.temp_comments = []
+        self.incremental = incremental
         if pr_url:
             self.set_pr(pr_url)
 

pr_agent/git_providers/git_provider.py

@@ -53,8 +53,11 @@ class GitProvider(ABC):
         pass
 
     @abstractmethod
-    def publish_code_suggestion(self, body: str, relevant_file: str,
-                                relevant_lines_start: int, relevant_lines_end: int):
+    def publish_code_suggestions(self, code_suggestions: list):
+        pass
+
+    @abstractmethod
+    def publish_labels(self, labels):
         pass
 
     @abstractmethod
@@ -121,3 +124,11 @@ def get_main_pr_language(languages, files) -> str:
         pass
 
     return main_language_str
+
+
+class IncrementalPR:
+    def __init__(self, is_incremental: bool = False):
+        self.is_incremental = is_incremental
+        self.commits_range = None
+        self.first_new_commit_sha = None
+        self.last_seen_commit_sha = None

pr_agent/git_providers/github_provider.py

@@ -7,12 +7,14 @@ from github import AppAuthentication, Github, Auth
 
 from pr_agent.config_loader import settings
 
-from .git_provider import FilePatchInfo, GitProvider
+from .git_provider import FilePatchInfo, GitProvider, IncrementalPR
 from ..algo.language_handler import is_valid_file
+from ..algo.utils import load_large_diff
 
 
 class GithubProvider(GitProvider):
-    def __init__(self, pr_url: Optional[str] = None):
+    def __init__(self, pr_url: Optional[str] = None, incremental=IncrementalPR(False)):
+        self.repo_obj = None
         self.installation_id = settings.get("GITHUB.INSTALLATION_ID")
         self.github_client = self._get_github_client()
         self.repo = None
@@ -20,6 +22,7 @@ class GithubProvider(GitProvider):
         self.pr = None
         self.github_user_id = None
         self.diff_files = None
+        self.incremental = incremental
         if pr_url:
             self.set_pr(pr_url)
             self.last_commit_id = list(self.pr.get_commits())[-1]
@@ -27,21 +30,73 @@ class GithubProvider(GitProvider):
     def is_supported(self, capability: str) -> bool:
         return True
 
+    def get_pr_url(self) -> str:
+        return f"https://github.com/{self.repo}/pull/{self.pr_num}"
+
     def set_pr(self, pr_url: str):
         self.repo, self.pr_num = self._parse_pr_url(pr_url)
         self.pr = self._get_pr()
+        if self.incremental.is_incremental:
+            self.get_incremental_commits()
+
+    def get_incremental_commits(self):
+        self.commits = list(self.pr.get_commits())
+
+        self.get_previous_review()
+        if self.previous_review:
+            self.incremental.commits_range = self.get_commit_range()
+            # Get all files changed during the commit range
+            self.file_set = dict()
+            for commit in self.incremental.commits_range:
+                if commit.commit.message.startswith(f"Merge branch '{self._get_repo().default_branch}'"):
+                    logging.info(f"Skipping merge commit {commit.commit.message}")
+                    continue
+                self.file_set.update({file.filename: file for file in commit.files})
+
+    def get_commit_range(self):
+        last_review_time = self.previous_review.created_at
+        first_new_commit_index = 0
+        for index in range(len(self.commits) - 1, -1, -1):
+            if self.commits[index].commit.author.date > last_review_time:
+                self.incremental.first_new_commit_sha = self.commits[index].sha
+                first_new_commit_index = index
+            else:
+                self.incremental.last_seen_commit_sha = self.commits[index].sha
+                break
+        return self.commits[first_new_commit_index:]
+
+    def get_previous_review(self):
+        self.previous_review = None
+        self.comments = list(self.pr.get_issue_comments())
+        for index in range(len(self.comments) - 1, -1, -1):
+            if self.comments[index].body.startswith("## PR Analysis"):
+                self.previous_review = self.comments[index]
+                break
 
     def get_files(self):
+        if self.incremental.is_incremental and self.file_set:
+            return self.file_set.values()
         return self.pr.get_files()
 
     def get_diff_files(self) -> list[FilePatchInfo]:
-        files = self.pr.get_files()
+        files = self.get_files()
         diff_files = []
         for file in files:
             if is_valid_file(file.filename):
-                original_file_content_str = self._get_pr_file_content(file, self.pr.base.sha)
                 new_file_content_str = self._get_pr_file_content(file, self.pr.head.sha)
-                diff_files.append(FilePatchInfo(original_file_content_str, new_file_content_str, file.patch, file.filename))
+                patch = file.patch
+                if self.incremental.is_incremental and self.file_set:
+                    original_file_content_str = self._get_pr_file_content(file, self.incremental.last_seen_commit_sha)
+                    patch = load_large_diff(file,
+                                            new_file_content_str,
+                                            original_file_content_str,
+                                             None)
+                    self.file_set[file.filename] = patch
+                else:
+                    original_file_content_str = self._get_pr_file_content(file, self.pr.base.sha)
+
+                diff_files.append(
+                    FilePatchInfo(original_file_content_str, new_file_content_str, patch, file.filename))
         self.diff_files = diff_files
         return diff_files
 
@@ -91,24 +146,32 @@ class GithubProvider(GitProvider):
     def publish_inline_comments(self, comments: list[dict]):
         self.pr.create_review(commit=self.last_commit_id, comments=comments)
 
-    def publish_code_suggestion(self, body: str,
-                                relevant_file: str,
-                                relevant_lines_start: int,
-                                relevant_lines_end: int):
-        if not relevant_lines_start or relevant_lines_start == -1:
-            if settings.config.verbosity_level >= 2:
-                logging.exception(f"Failed to publish code suggestion, relevant_lines_start is {relevant_lines_start}")
-            return False
+    def publish_code_suggestions(self, code_suggestions: list):
+        """
+        Publishes code suggestions as comments on the PR.
+        In practice current APU enables to send only one code suggestion per comment. Might change in the future.
+        """
+        post_parameters_list = []
+        import github.PullRequestComment
+        for suggestion in code_suggestions:
+            body = suggestion['body']
+            relevant_file = suggestion['relevant_file']
+            relevant_lines_start = suggestion['relevant_lines_start']
+            relevant_lines_end = suggestion['relevant_lines_end']
 
-        if relevant_lines_end<relevant_lines_start:
-            if settings.config.verbosity_level >= 2:
-                logging.exception(f"Failed to publish code suggestion, "
-                                  f"relevant_lines_end is {relevant_lines_end} and "
-                                  f"relevant_lines_start is {relevant_lines_start}")
-            return False
+            if not relevant_lines_start or relevant_lines_start == -1:
+                if settings.config.verbosity_level >= 2:
+                    logging.exception(
+                        f"Failed to publish code suggestion, relevant_lines_start is {relevant_lines_start}")
+                continue
+
+            if relevant_lines_end < relevant_lines_start:
+                if settings.config.verbosity_level >= 2:
+                    logging.exception(f"Failed to publish code suggestion, "
+                                      f"relevant_lines_end is {relevant_lines_end} and "
+                                      f"relevant_lines_start is {relevant_lines_start}")
+                continue
 
-        try:
-            import github.PullRequestComment
             if relevant_lines_end > relevant_lines_start:
                 post_parameters = {
                     "body": body,
@@ -126,17 +189,19 @@ class GithubProvider(GitProvider):
                     "line": relevant_lines_start,
                     "side": "RIGHT",
                 }
-            headers, data = self.pr._requester.requestJsonAndCheck(
-                "POST", f"{self.pr.url}/comments", input=post_parameters
-            )
-            github.PullRequestComment.PullRequestComment(
-                self.pr._requester, headers, data, completed=True
-            )
-            return True
-        except Exception as e:
-            if settings.config.verbosity_level >= 2:
-                logging.error(f"Failed to publish code suggestion, error: {e}")
-            return False
+
+            try:
+                headers, data = self.pr._requester.requestJsonAndCheck(
+                    "POST", f"{self.pr.url}/comments", input=post_parameters
+                )
+                github.PullRequestComment.PullRequestComment(
+                    self.pr._requester, headers, data, completed=True
+                )
+                return True
+            except Exception as e:
+                if settings.config.verbosity_level >= 2:
+                    logging.error(f"Failed to publish code suggestion, error: {e}")
+                return False
 
     def remove_initial_comment(self):
         try:
@@ -233,7 +298,14 @@ class GithubProvider(GitProvider):
             return Github(auth=Auth.Token(token))
 
     def _get_repo(self):
-        return self.github_client.get_repo(self.repo)
+        if hasattr(self, 'repo_obj') and \
+                hasattr(self.repo_obj, 'full_name') and \
+                self.repo_obj.full_name == self.repo:
+            return self.repo_obj
+        else:
+            self.repo_obj = self.github_client.get_repo(self.repo)
+            return self.repo_obj
+
 
     def _get_pr(self):
         return self._get_repo().get_pull(self.pr_num)
@@ -244,3 +316,16 @@ class GithubProvider(GitProvider):
         except Exception:
             file_content_str = ""
         return file_content_str
+
+    def publish_labels(self, pr_types):
+        try:
+            label_color_map = {"Bug fix": "1d76db", "Tests": "e99695", "Bug fix with tests": "c5def5", "Refactoring": "bfdadc", "Enhancement": "bfd4f2", "Documentation": "d4c5f9", "Other": "d1bcf9"}
+            post_parameters = []
+            for p in pr_types:
+                color = label_color_map.get(p, "d1bcf9")  # default to "Other" color
+                post_parameters.append({"name": p, "color": color})
+            headers, data = self.pr._requester.requestJsonAndCheck(
+                "PUT", f"{self.pr.issue_url}/labels", input=post_parameters
+            )
+        except:
+            logging.exception("Failed to publish labels")

pr_agent/git_providers/gitlab_provider.py

@@ -13,7 +13,7 @@ from ..algo.language_handler import is_valid_file
 
 
 class GitLabProvider(GitProvider):
-    def __init__(self, merge_request_url: Optional[str] = None):
+    def __init__(self, merge_request_url: Optional[str] = None, incremental: Optional[bool] = False):
         gitlab_url = settings.get("GITLAB.URL", None)
         if not gitlab_url:
             raise ValueError("GitLab URL is not set in the config file")
@@ -32,6 +32,7 @@ class GitLabProvider(GitProvider):
         self._set_merge_request(merge_request_url)
         self.RE_HUNK_HEADER = re.compile(
             r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@[ ]?(.*)")
+        self.incremental = incremental
 
     def is_supported(self, capability: str) -> bool:
         if capability in ['get_issue_comments', 'create_inline_comment', 'publish_inline_comments']:
@@ -134,26 +135,29 @@ class GitLabProvider(GitProvider):
             self.mr.discussions.create({'body': body,
                                         'position': pos_obj})
 
-    def publish_code_suggestion(self, body: str,
-                                relevant_file: str,
-                                relevant_lines_start: int,
-                                relevant_lines_end: int):
-        self.diff_files = self.diff_files if self.diff_files else self.get_diff_files()
-        target_file = None
-        for file in self.diff_files:
-            if file.filename == relevant_file:
-                if file.filename == relevant_file:
-                    target_file = file
-                    break
-        range = relevant_lines_end - relevant_lines_start + 1
-        body = body.replace('```suggestion', f'```suggestion:-0+{range}')
+    def publish_code_suggestions(self, code_suggestions: list):
+        for suggestion in code_suggestions:
+            body = suggestion['body']
+            relevant_file = suggestion['relevant_file']
+            relevant_lines_start = suggestion['relevant_lines_start']
+            relevant_lines_end = suggestion['relevant_lines_end']
 
-        lines = target_file.head_file.splitlines()
-        relevant_line_in_file = lines[relevant_lines_start - 1]
-        edit_type, found, source_line_no, target_file, target_line_no = self.find_in_file(target_file,
-                                                                                          relevant_line_in_file)
-        self.send_inline_comment(body, edit_type, found, relevant_file, relevant_line_in_file, source_line_no,
-                                 target_file, target_line_no)
+            self.diff_files = self.diff_files if self.diff_files else self.get_diff_files()
+            target_file = None
+            for file in self.diff_files:
+                if file.filename == relevant_file:
+                    if file.filename == relevant_file:
+                        target_file = file
+                        break
+            range = relevant_lines_end - relevant_lines_start + 1
+            body = body.replace('```suggestion', f'```suggestion:-0+{range}')
+
+            lines = target_file.head_file.splitlines()
+            relevant_line_in_file = lines[relevant_lines_start - 1]
+            edit_type, found, source_line_no, target_file, target_line_no = self.find_in_file(target_file,
+                                                                                              relevant_line_in_file)
+            self.send_inline_comment(body, edit_type, found, relevant_file, relevant_line_in_file, source_line_no,
+                                     target_file, target_line_no)
 
     def search_line(self, relevant_file, relevant_line_in_file):
         target_file = None
@@ -253,3 +257,6 @@ class GitLabProvider(GitProvider):
 
     def get_user_id(self):
         return None
+
+    def publish_labels(self, labels):
+        pass

pr_agent/servers/help.py

@@ -1,8 +1,9 @@
-commands_text = "> /review - Request a review of the latest update to the PR.\n" \
-                "> /describe - Modify the PR title and description based on the contents of the PR.\n" \
-                "> /improve - Suggest improvements to the code in the PR. " \
+commands_text = "> **/review [-i]**: Request a review of your Pull Request. For an incremental review, which only " \
+                "considers changes since the last review, include the '-i' option.\n" \
+                "> **/describe**: Modify the PR title and description based on the contents of the PR.\n" \
+                "> **/improve**: Suggest improvements to the code in the PR. " \
                 "These will be provided as pull request comments, ready to commit.\n" \
-                "> /ask <QUESTION> - Pose a question about the PR.\n"
+                "> **/ask \\<QUESTION\\>**: Pose a question about the PR.\n"
 
 
 def bot_help_text(user: str):

pr_agent/settings/configuration.toml

@@ -6,9 +6,10 @@ verbosity_level=0 # 0,1,2
 
 [pr_reviewer]
 require_focused_review=true
+require_score_review=false
 require_tests_review=true
 require_security_review=true
-num_code_suggestions=3
+num_code_suggestions=0
 inline_code_comments = true
 ask_and_reflect=false
 

pr_agent/settings/pr_description_prompts.toml

@@ -10,9 +10,9 @@ You must use the following JSON schema to format your answer:
       "type": "string",
       "description": "an informative title for the PR, describing its main theme"
   },
-  "Type of PR": {
+  "PR Type": {
       "type": "string",
-      "enum": ["Bug fix", "Tests", "Bug fix with tests", "Refactoring", "Enhancement", "Documentation", "Other"]
+      "description": possible values are: ["Bug fix", "Tests", "Bug fix with tests", "Refactoring", "Enhancement", "Documentation", "Other"]
     },
   "PR Description": {
       "type": "string",

pr_agent/settings/pr_reviewer_prompts.toml

@@ -20,6 +20,12 @@ You must use the following JSON schema to format your answer:
       "type": "string",
       "enum": ["Bug fix", "Tests", "Bug fix with tests", "Refactoring", "Enhancement", "Documentation", "Other"]
     },
+{%- if require_score %}
+    "Score": {
+      "type": "int",
+      "description": "Rate this PR on a scale of 0-100 (inclusive), where 0 means the worst possible PR code, and 100 means PR code of the highest quality, without any bugs or performance issues, that is ready to be merged immediately and run in production at scale."
+    },
+{%- endif %}
 {%- if require_tests %}
     "Relevant tests added": {
       "type": "string",
@@ -83,6 +89,9 @@ Example output:
     {
         "Main theme": "xxx",
         "Type of PR": "Bug fix",
+{%- if require_score %}
+        "Score": 89,
+{%- endif %}
 {%- if require_tests %}
         "Relevant tests added": "No",
 {%- endif %}
@@ -103,8 +112,8 @@ Example output:
             ...
         ]
 {%- endif %}
-{%- if require_security %},
-       "Security concerns": "No, because ..."
+{%- if require_security %}
+        "Security concerns": "No, because ..."
 {%- endif %}
     }
 }

pr_agent/tools/pr_code_suggestions.py

@@ -79,7 +79,6 @@ class PRCodeSuggestions:
 
     def _prepare_pr_code_suggestions(self) -> str:
         review = self.prediction.strip()
-        data = None
         try:
             data = json.loads(review)
         except json.decoder.JSONDecodeError:
@@ -89,6 +88,7 @@ class PRCodeSuggestions:
         return data
 
     def push_inline_code_suggestions(self, data):
+        code_suggestions = []
         for d in data['Code suggestions']:
             if settings.config.verbosity_level >= 2:
                 logging.info(f"suggestion: {d}")
@@ -100,27 +100,33 @@ class PRCodeSuggestions:
             new_code_snippet = d['improved code']
 
             if new_code_snippet:
-                try:  # dedent code snippet
-                    self.diff_files = self.git_provider.diff_files if self.git_provider.diff_files \
-                        else self.git_provider.get_diff_files()
-                    original_initial_line = None
-                    for file in self.diff_files:
-                        if file.filename.strip() == relevant_file:
-                            original_initial_line = file.head_file.splitlines()[relevant_lines_start - 1]
-                            break
-                    if original_initial_line:
-                        suggested_initial_line = new_code_snippet.splitlines()[0]
-                        original_initial_spaces = len(original_initial_line) - len(original_initial_line.lstrip())
-                        suggested_initial_spaces = len(suggested_initial_line) - len(suggested_initial_line.lstrip())
-                        delta_spaces = original_initial_spaces - suggested_initial_spaces
-                        if delta_spaces > 0:
-                            new_code_snippet = textwrap.indent(new_code_snippet, delta_spaces * " ").rstrip('\n')
-                except Exception as e:
-                    if settings.config.verbosity_level >= 2:
-                        logging.info(f"Could not dedent code snippet for file {relevant_file}, error: {e}")
+                new_code_snippet = self.dedent_code(relevant_file, relevant_lines_start, new_code_snippet)
 
             body = f"**Suggestion:** {content}\n```suggestion\n" + new_code_snippet + "\n```"
-            self.git_provider.publish_code_suggestion(body=body,
-                                                      relevant_file=relevant_file,
-                                                      relevant_lines_start=relevant_lines_start,
-                                                      relevant_lines_end=relevant_lines_end)
+            code_suggestions.append({'body': body,'relevant_file': relevant_file,
+                                     'relevant_lines_start': relevant_lines_start,
+                                     'relevant_lines_end': relevant_lines_end})
+
+        self.git_provider.publish_code_suggestions(code_suggestions)
+
+    def dedent_code(self, relevant_file, relevant_lines_start, new_code_snippet):
+        try:  # dedent code snippet
+            self.diff_files = self.git_provider.diff_files if self.git_provider.diff_files \
+                else self.git_provider.get_diff_files()
+            original_initial_line = None
+            for file in self.diff_files:
+                if file.filename.strip() == relevant_file:
+                    original_initial_line = file.head_file.splitlines()[relevant_lines_start - 1]
+                    break
+            if original_initial_line:
+                suggested_initial_line = new_code_snippet.splitlines()[0]
+                original_initial_spaces = len(original_initial_line) - len(original_initial_line.lstrip())
+                suggested_initial_spaces = len(suggested_initial_line) - len(suggested_initial_line.lstrip())
+                delta_spaces = original_initial_spaces - suggested_initial_spaces
+                if delta_spaces > 0:
+                    new_code_snippet = textwrap.indent(new_code_snippet, delta_spaces * " ").rstrip('\n')
+        except Exception as e:
+            if settings.config.verbosity_level >= 2:
+                logging.info(f"Could not dedent code snippet for file {relevant_file}, error: {e}")
+
+        return new_code_snippet

pr_agent/tools/pr_description.py

@@ -42,13 +42,14 @@ class PRDescription:
         logging.info('Getting AI prediction...')
         self.prediction = await self._get_prediction()
         logging.info('Preparing answer...')
-        pr_title, pr_body, markdown_text = self._prepare_pr_answer()
+        pr_title, pr_body, pr_types, markdown_text = self._prepare_pr_answer()
         if settings.config.publish_output:
             logging.info('Pushing answer...')
             if settings.pr_description.publish_description_as_comment:
                 self.git_provider.publish_comment(markdown_text)
             else:
                 self.git_provider.publish_description(pr_title, pr_body)
+                self.git_provider.publish_labels(pr_types)
             self.git_provider.remove_initial_comment()
         return ""
 
@@ -73,6 +74,9 @@ class PRDescription:
             markdown_text += f"## {key}\n\n"
             markdown_text += f"{value}\n\n"
         pr_body = ""
+        pr_types = []
+        if 'PR Type' in data:
+            pr_types = data['PR Type'].split(',')
         title = data['PR Title']
         del data['PR Title']
         for key, value in data.items():
@@ -83,4 +87,4 @@ class PRDescription:
                 pr_body += f"**{value}**\n\n___\n"
         if settings.config.verbosity_level >= 2:
             logging.info(f"title:\n{title}\n{pr_body}")
-        return title, pr_body, markdown_text
+        return title, pr_body, pr_types, markdown_text

pr_agent/tools/pr_questions.py

@@ -12,7 +12,8 @@ from pr_agent.git_providers.git_provider import get_main_pr_language
 
 
 class PRQuestions:
-    def __init__(self, pr_url: str, question_str: str):
+    def __init__(self, pr_url: str, args=None):
+        question_str = self.parse_args(args)
         self.git_provider = get_git_provider()(pr_url)
         self.main_pr_language = get_main_pr_language(
             self.git_provider.get_languages(), self.git_provider.get_files()
@@ -34,6 +35,13 @@ class PRQuestions:
         self.patches_diff = None
         self.prediction = None
 
+    def parse_args(self, args):
+        if args and len(args) > 0:
+            question_str = " ".join(args)
+        else:
+            question_str = ""
+        return question_str
+
     async def answer(self):
         logging.info('Answering a PR question...')
         if settings.config.publish_output:

pr_agent/tools/pr_reviewer.py

@@ -1,6 +1,7 @@
 import copy
 import json
 import logging
+from collections import OrderedDict
 
 from jinja2 import Environment, StrictUndefined
 
@@ -10,17 +11,19 @@ from pr_agent.algo.token_handler import TokenHandler
 from pr_agent.algo.utils import convert_to_markdown, try_fix_json
 from pr_agent.config_loader import settings
 from pr_agent.git_providers import get_git_provider
-from pr_agent.git_providers.git_provider import get_main_pr_language
+from pr_agent.git_providers.git_provider import get_main_pr_language, IncrementalPR
 from pr_agent.servers.help import actions_help_text, bot_help_text
 
 
 class PRReviewer:
-    def __init__(self, pr_url: str, cli_mode=False, is_answer: bool = False):
+    def __init__(self, pr_url: str, cli_mode=False, is_answer: bool = False, args=None):
+        self.parse_args(args)
 
-        self.git_provider = get_git_provider()(pr_url)
+        self.git_provider = get_git_provider()(pr_url, incremental=self.incremental)
         self.main_language = get_main_pr_language(
             self.git_provider.get_languages(), self.git_provider.get_files()
         )
+        self.pr_url = pr_url
         self.is_answer = is_answer
         if self.is_answer and not self.git_provider.is_supported("get_issue_comments"):
             raise Exception(f"Answer mode is not supported for {settings.config.git_provider} for now")
@@ -35,6 +38,7 @@ class PRReviewer:
             "description": self.git_provider.get_pr_description(),
             "language": self.main_language,
             "diff": "",  # empty diff for initial calculation
+            "require_score": settings.pr_reviewer.require_score_review,
             "require_tests": settings.pr_reviewer.require_tests_review,
             "require_security": settings.pr_reviewer.require_security_review,
             "require_focused": settings.pr_reviewer.require_focused_review,
@@ -48,6 +52,14 @@ class PRReviewer:
                                           settings.pr_review_prompt.system,
                                           settings.pr_review_prompt.user)
 
+    def parse_args(self, args):
+        is_incremental = False
+        if args and len(args) >= 1:
+            arg = args[0]
+            if arg == "-i":
+                is_incremental = True
+        self.incremental = IncrementalPR(is_incremental)
+
     async def review(self):
         logging.info('Reviewing PR...')
         if settings.config.publish_output:
@@ -107,6 +119,14 @@ class PRReviewer:
             if not data['PR Feedback']['Code suggestions']:
                 del data['PR Feedback']['Code suggestions']
 
+        if self.incremental.is_incremental:
+            # Rename title when incremental review - Add to the beginning of the dict
+            last_commit_url = f"{self.git_provider.get_pr_url()}/commits/{self.git_provider.incremental.first_new_commit_sha}"
+            data = OrderedDict(data)
+            data.update({'Incremental PR Review': {
+                "⏮️ Review for commits since previous PR-Agent review": f"Starting from commit {last_commit_url}"}})
+            data.move_to_end('Incremental PR Review', last=False)
+
         markdown_text = convert_to_markdown(data)
         user = self.git_provider.get_user_id()