Merge remote-tracking branch 'origin/main' into pg/pip_package

Handling GitHub API Rate Limit Exceeded Exception

.dockerignore

@@ -1,2 +1,3 @@
 venv/
-pr_agent/settings/.secrets.toml
+pr_agent/settings/.secrets.toml
+pics/

.github/workflows/review.yaml

@@ -0,0 +1,16 @@
+on:
+  pull_request:
+  issue_comment:
+jobs:
+  pr_agent_job:
+    runs-on: ubuntu-latest
+    name: Run pr agent on every pull request
+    steps:
+      - name: PR Agent action step
+        id: pragent
+        uses: Codium-ai/pr-agent@main
+        env:
+          OPENAI_KEY: ${{ secrets.OPENAI_KEY }}
+          OPENAI_ORG: ${{ secrets.OPENAI_ORG }} # optional
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+

.gitignore

@@ -1,4 +1,6 @@
 .idea/
 venv/
 pr_agent/settings/.secrets.toml
-__pycache__
+__pycache__
+dist/
+*.egg-info/

CHANGELOG.md

@@ -0,0 +1,6 @@
+## 2023-07-26
+
+### Added
+- New feature for updating the CHANGELOG.md based on the contents of a PR.
+- Added support for this feature for the Github provider.
+- New configuration settings and prompts for the changelog update feature.

CONFIGURATION.md

@@ -0,0 +1,19 @@
+## Configuration
+
+The different tools and sub-tools used by CodiumAI pr-agent are easily configurable via the configuration file: `/pr-agent/settings/configuration.toml`.
+##### Git Provider:
+You can select your git_provider with the flag `git_provider` in the `config` section
+
+##### PR Reviewer:
+
+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
+```
+You can contol the number of suggestions returned by the PR Reviewer with the following flag:
+```inline_code_comments=3```
+And enable/disable the inline code suggestions with the following flag:
+```inline_code_comments=true```

Dockerfile.github_action

@@ -0,0 +1,10 @@
+FROM python:3.10 as base
+
+WORKDIR /app
+ADD pyproject.toml .
+RUN pip install . && rm pyproject.toml
+ENV PYTHONPATH=/app
+ADD pr_agent pr_agent
+ADD github_action/entrypoint.sh /
+RUN chmod +x /entrypoint.sh
+ENTRYPOINT ["/entrypoint.sh"]

Dockerfile.github_action_dockerhub

@@ -0,0 +1 @@
+FROM codiumai/pr-agent:github_action

INSTALL.md

@@ -0,0 +1,218 @@
+
+## Installation
+
+---
+
+#### Method 1: Use Docker image (no installation required)
+
+To request a review for a PR, or ask a question about a PR, you can run directly from the Docker image. Here's how:
+
+1. To request a review for a PR, run the following command:
+
+```
+docker run --rm -it -e OPENAI.KEY=<your key> -e GITHUB.USER_TOKEN=<your token> codiumai/pr-agent --pr_url <pr_url> review
+```
+
+2. To ask a question about a PR, run the following command:
+
+```
+docker run --rm -it -e OPENAI.KEY=<your key> -e GITHUB.USER_TOKEN=<your token> codiumai/pr-agent --pr_url <pr_url> ask "<your question>"
+```
+
+Possible questions you can ask include:
+
+- What is the main theme of this PR?
+- Is the PR ready for merge?
+- What are the main changes in this PR?
+- Should this PR be split into smaller parts?
+- Can you compose a rhymed song about this PR?
+
+---
+
+#### Method 2: Run as a GitHub Action
+
+You can use our pre-built Github Action Docker image to run PR-Agent as a Github Action. 
+
+1. Add the following file to your repository under `.github/workflows/pr_agent.yml`:
+
+```yaml
+on:
+  pull_request:
+  issue_comment:
+jobs:
+  pr_agent_job:
+    runs-on: ubuntu-latest
+    name: Run pr agent on every pull request, respond to user comments
+    steps:
+      - name: PR Agent action step
+        id: pragent
+        uses: Codium-ai/pr-agent@main
+        env:
+          OPENAI_KEY: ${{ secrets.OPENAI_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+```
+
+2. Add the following secret to your repository under `Settings > Secrets`:
+
+```
+OPENAI_KEY: <your key>
+```
+
+The GITHUB_TOKEN secret is automatically created by GitHub.
+
+3. Merge this change to your main branch. 
+When you open your next PR, you should see a comment from `github-actions` bot with a review of your PR, and instructions on how to use the rest of the tools.
+
+4. You may configure PR-Agent by adding environment variables under the env section corresponding to any configurable property in the [configuration](./CONFIGURATION.md) file. Some examples:
+```yaml
+      env:
+        # ... previous environment values
+        OPENAI.ORG: "<Your organization name under your OpenAI account>"
+        PR_REVIEWER.REQUIRE_TESTS_REVIEW: "false" # Disable tests review
+        PR_CODE_SUGGESTIONS.NUM_CODE_SUGGESTIONS: 6 # Increase number of code suggestions
+```
+
+---
+
+#### Method 3: Run from source
+
+1. Clone this repository:
+
+```
+git clone https://github.com/Codium-ai/pr-agent.git
+```
+
+2. Install the requirements in your favorite virtual environment:
+
+```
+pip install -r requirements.txt
+```
+
+3. Copy the secrets template file and fill in your OpenAI key and your GitHub user token:
+
+```
+cp pr_agent/settings/.secrets_template.toml pr_agent/settings/.secrets.toml
+# Edit .secrets.toml file
+```
+
+4. Add the pr_agent folder to your PYTHONPATH, then run the cli.py script:
+
+```
+export PYTHONPATH=[$PYTHONPATH:]<PATH to pr_agent folder>
+python pr_agent/cli.py --pr_url <pr_url> review
+python pr_agent/cli.py --pr_url <pr_url> ask <your question>
+python pr_agent/cli.py --pr_url <pr_url> describe
+python pr_agent/cli.py --pr_url <pr_url> improve
+```
+
+---
+
+#### Method 4: Run as a polling server
+Request reviews by tagging your Github user on a PR
+
+Follow steps 1-3 of method 2.
+Run the following command to start the server:
+
+```
+python pr_agent/servers/github_polling.py
+```
+
+---
+
+#### Method 5: Run as a GitHub App
+Allowing you to automate the review process on your private or public repositories.
+
+1. Create a GitHub App from the [Github Developer Portal](https://docs.github.com/en/developers/apps/creating-a-github-app).
+
+   - Set the following permissions:
+     - Pull requests: Read & write
+     - Issue comment: Read & write
+     - Metadata: Read-only
+   - Set the following events:
+     - Issue comment
+     - Pull request
+
+2. Generate a random secret for your app, and save it for later. For example, you can use:
+
+```
+WEBHOOK_SECRET=$(python -c "import secrets; print(secrets.token_hex(10))")
+```
+
+3. Acquire the following pieces of information from your app's settings page:
+
+   - App private key (click "Generate a private key" and save the file)
+   - App ID
+
+4. Clone this repository:
+
+```
+git clone https://github.com/Codium-ai/pr-agent.git
+```
+
+5. Copy the secrets template file and fill in the following:
+    ```
+    cp pr_agent/settings/.secrets_template.toml pr_agent/settings/.secrets.toml
+    # Edit .secrets.toml file
+    ```
+   - Your OpenAI key.
+   - Copy your app's private key to the private_key field.
+   - Copy your app's ID to the app_id field.
+   - Copy your app's webhook secret to the webhook_secret field.
+   - Set deployment_type to 'app' in [configuration.toml](./pr_agent/settings/configuration.toml)
+
+> The .secrets.toml file is not copied to the Docker image by default, and is only used for local development. 
+> If you want to use the .secrets.toml file in your Docker image, you can add remove it from the .dockerignore file.
+> In most production environments, you would inject the secrets file as environment variables or as mounted volumes. 
+> For example, in order to inject a secrets file as a volume in a Kubernetes environment you can update your pod spec to include the following,
+> assuming you have a secret named `pr-agent-settings` with a key named `.secrets.toml`:
+``` 
+       volumes:
+        - name: settings-volume
+          secret:
+            secretName: pr-agent-settings
+// ...
+       containers:
+// ...
+          volumeMounts:
+            - mountPath: /app/pr_agent/settings_prod
+              name: settings-volume
+```
+
+> Another option is to set the secrets as environment variables in your deployment environment, for example `OPENAI.KEY` and `GITHUB.USER_TOKEN`.
+
+6. Build a Docker image for the app and optionally push it to a Docker repository. We'll use Dockerhub as an example:
+
+```
+docker build . -t codiumai/pr-agent:github_app --target github_app -f docker/Dockerfile
+docker push codiumai/pr-agent:github_app  # Push to your Docker repository
+```
+
+7. Host the app using a server, serverless function, or container environment. Alternatively, for development and
+   debugging, you may use tools like smee.io to forward webhooks to your local machine.
+    You can check [Deploy as a Lambda Function](#deploy-as-a-lambda-function)
+
+8. Go back to your app's settings, and set the following:
+
+   - Webhook URL: The URL of your app's server or the URL of the smee.io channel.
+   - Webhook secret: The secret you generated earlier.
+
+9. Install the app by navigating to the "Install App" tab and selecting your desired repositories.
+
+---
+
+####  Deploy as a Lambda Function
+
+1. Follow steps 1-5 of [Method 5](#method-5-run-as-a-github-app).
+2. Build a docker image that can be used as a lambda function
+    ```shell
+    docker buildx build --platform=linux/amd64 . -t codiumai/pr-agent:serverless -f docker/Dockerfile.lambda
+   ```
+3. Push image to ECR
+    ```shell
+	docker tag codiumai/pr-agent:serverless <AWS_ACCOUNT>.dkr.ecr.<AWS_REGION>.amazonaws.com/codiumai/pr-agent:serverless
+	docker push <AWS_ACCOUNT>.dkr.ecr.<AWS_REGION>.amazonaws.com/codiumai/pr-agent:serverless
+    ```
+4. Create a lambda function that uses the uploaded image. Set the lambda timeout to be at least 3m.
+5. Configure the lambda function to have a Function URL.
+6. Go back to steps 8-9 of [Method 5](#method-5-run-as-a-github-app) with the function url as your Webhook URL.
+    The Webhook URL would look like `https://<LAMBDA_FUNCTION_URL>/api/v1/github_webhooks`

PR_COMPRESSION.md

@@ -39,4 +39,4 @@ We use [tiktoken](https://github.com/openai/tiktoken) to tokenize the patches af
 4. If we haven't reached the max token length, add the `deleted files` to the prompt until the prompt reaches the max token length (hard stop), skip the rest of the patches.
 
 ### Example
-![](./pics/git_patch_logic.png)
+![](https://codium.ai/images/git_patch_logic.png)

README.md

@@ -2,309 +2,177 @@
 
 <div align="center">
 
-<img src="./pics/logo-dark.png#gh-dark-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="250"/>
+<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)
 [![Discord](https://badgen.net/badge/icon/discord?icon=discord&label&color=purple)](https://discord.com/channels/1057273017547378788/1126104260430528613)
-
+    <a href="https://github.com/Codium-ai/pr-agent/commits/main">
-CodiumAI `pr-agent` is an open-source tool aiming to help developers review PRs faster and more efficiently. It automatically analyzes the PR, provides feedback and suggestions, and can answer free-text questions.
+    <img alt="GitHub" src="https://img.shields.io/github/last-commit/Codium-ai/pr-agent/main?style=for-the-badge" height="20">
-
+    </a>
 </div>
+<div style="text-align:left;">
 
-- [Live demo](#live-demo)
+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:
-- [Quickstart](#Quickstart)
+
+**Auto-Description**: Automatically generating PR description - title, type, summary, code walkthrough and PR labels.
+\
+**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.
+\
+**Code Suggestion**: Committable code suggestions for improving the PR.
+
+<h3>Example results:</h2>
+</div>
+<h4>/describe:</h4>
+<div align="center">
+<p float="center">
+<img src="https://www.codium.ai/images/describe-2.gif" width="800">
+</p>
+</div>
+<h4>/review:</h4>
+<div align="center">
+<p float="center">
+<img src="https://www.codium.ai/images/review-2.gif" width="800">
+</p>
+</div>
+<h4>/reflect_and_review:</h4>
+<div align="center">
+<p float="center">
+<img src="https://www.codium.ai/images/reflect_and_review.gif" width="800">
+</p>
+</div>
+<h4>/ask:</h4>
+<div align="center">
+<p float="center">
+<img src="https://www.codium.ai/images/ask-2.gif" width="800">
+</p>
+</div>
+<h4>/improve:</h4>
+<div align="center">
+<p float="center">
+<img src="https://www.codium.ai/images/improve-2.gif" width="800">
+</p>
+</div>
+<div align="left">
+
+
+- [Overview](#overview)
+- [Try it now](#try-it-now)
+- [Installation](#installation)
 - [Usage and tools](#usage-and-tools)
-- [Configuration](#Configuration)
+- [Configuration](./CONFIGURATION.md)
 - [How it works](#how-it-works)
+- [Why use PR-Agent](#why-use-pr-agent)
 - [Roadmap](#roadmap)
 - [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` in any PR comment! The agent will generate a PR review in response.
+## Overview
+`PR-Agent` offers extensive pull request functionalities across various git providers:
+|       |                                             | GitHub | Gitlab | Bitbucket |
+|-------|---------------------------------------------|:------:|:------:|:---------:|
+| TOOLS | Review                                      |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:       |
+|       | ⮑ Inline review                             |   :white_check_mark:    |   :white_check_mark:    |           |
+|       | Ask                                         |   :white_check_mark:    |   :white_check_mark:    |           |
+|       | Auto-Description                            |   :white_check_mark:    |  :white_check_mark:      |           |
+|       | Improve Code                                |   :white_check_mark:    |   :white_check_mark:    |           |
+|       | Reflect and Review                          |   :white_check_mark:    |                         |           |
+|       | Update CHANGELOG.md                         |   :white_check_mark:    |                         |           |
+|       |                                             |        |        |           |
+| USAGE | CLI                                         |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:       |
+|       | App / webhook                               |   :white_check_mark:    |   :white_check_mark:    |           |
+|       | Tagging bot                                 |   :white_check_mark:    |        |           |
+|       | Actions                                     |   :white_check_mark:    |        |           |
+|       |                                             |        |        |           |
+| 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:    |      |         |
 
-![Review generation process](./pics/pr-agent-review-process1.gif)
+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
+- **Ask**:          python cli.py --pr-url=<pr_url>  ask "Write me a poem about this PR"
+- **Reflect**:      python cli.py --pr-url=<pr_url>  reflect
+- **Update changelog**:      python cli.py --pr-url=<pr_url>  update_changelog
 
-To set up your own pr-agent, see the [Quickstart](#Quickstart) section
+"<pr_url>" is the url of the relevant PR (for example: https://github.com/Codium-ai/pr-agent/pull/50).
+
+In the [configuration](./CONFIGURATION.md) file you can select your git provider (GitHub, Gitlab, Bitbucket), and further configure the different tools.
+
+## 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://www.codium.ai/images/demo-2.gif)
+
+To set up your own PR-Agent, see the [Installation](#installation) section
 
 ---
 
-## Quickstart
+## Installation
 
-To get started with pr-agent quickly, you first need to acquire two tokens:
+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:
+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)
-#### Method 1: Use Docker image (no installation required)
+- [Method 3: Run from source](INSTALL.md#method-3-run-from-source)
-
+- [Method 4: Run as a polling server](INSTALL.md#method-4-run-as-a-polling-server)
-To request a review for a PR, or ask a question about a PR, you can run directly from the Docker image. Here's how:
+  - Request reviews by tagging your GitHub user on a PR
-
+- [Method 5: Run as a GitHub App](INSTALL.md#method-5-run-as-a-github-app)
-1. To request a review for a PR, run the following command:
+  - Allowing you to automate the review process on your private or public repositories
-
-```
-docker run --rm -it -e OPENAI.KEY=<your key> -e GITHUB.USER_TOKEN=<your token> codiumai/pr-agent --pr_url <pr url>
-```
-
-2. To ask a question about a PR, run the following command:
-
-```
-docker run --rm -it -e OPENAI.KEY=<your key> -e GITHUB.USER_TOKEN=<your token> codiumai/pr-agent --pr_url <pr url> --question "<your question>"
-```
-
-Possible questions you can ask include:
-
-- What is the main theme of this PR?
-- Is the PR ready for merge?
-- What are the main changes in this PR?
-- Should this PR be split into smaller parts?
-- Can you compose a rhymed song about this PR.
-
----
-
-#### Method 2: Run from source
-
-1. Clone this repository:
-
-```
-git clone https://github.com/Codium-ai/pr-agent.git
-```
-
-2. Install the requirements in your favorite virtual environment:
-
-```
-pip install -r requirements.txt
-```
-
-3. Copy the secrets template file and fill in your OpenAI key and your GitHub user token:
-
-```
-cp pr_agent/settings/.secrets_template.toml pr_agent/settings/.secrets.toml
-# Edit .secrets.toml file
-```
-
-4. Run the appropriate Python scripts from the scripts folder:
-
-```
-python pr_agent/cli.py --pr_url <pr url>
-python pr_agent/cli.py --pr_url <pr url> --question "<your question>"
-```
-
----
-
-#### Method 3: Method 3: Run as a polling server; request reviews by tagging your Github user on a PR
-
-Follow steps 1-3 of method 2.
-Run the following command to start the server:
-
-```
-python pr_agent/servers/github_polling.py
-```
-
----
-
-#### Method 4: Run as a Github App, allowing you to automate the review process on your private or public repositories.
-
-1. Create a GitHub App from the [Github Developer Portal](https://docs.github.com/en/developers/apps/creating-a-github-app).
-
-   - Set the following permissions:
-     - Pull requests: Read & write
-     - Issue comment: Read & write
-     - Metadata: Read-only
-   - Set the following events:
-     - Issue comment
-     - Pull request
-
-2. Generate a random secret for your app, and save it for later. For example, you can use:
-
-```
-WEBHOOK_SECRET=$(python -c "import secrets; print(secrets.token_hex(10))")
-```
-
-3. Acquire the following pieces of information from your app's settings page:
-
-   - App private key (click "Generate a private key", and save the file)
-   - App ID
-
-4. Clone this repository:
-
-```
-git clone https://github.com/Codium-ai/pr-agent.git
-```
-
-5. Copy the secrets template file and fill in the following:
-   - Your OpenAI key.
-   - Set deployment_type to 'app'
-   - Copy your app's private key to the private_key field.
-   - Copy your app's ID to the app_id field.
-   - Copy your app's webhook secret to the webhook_secret field.
-
-```
-cp pr_agent/settings/.secrets_template.toml pr_agent/settings/.secrets.toml
-# Edit .secrets.toml file
-```
-
-6. Build a Docker image for the app and optionally push it to a Docker repository. We'll use Dockerhub as an example:
-
-```
-docker build . -t codiumai/pr-agent:github_app --target github_app -f docker/Dockerfile
-docker push codiumai/pr-agent:github_app  # Push to your Docker repository
-```
-
-7. Host the app using a server, serverless function, or container environment. Alternatively, for development and
-   debugging, you may use tools like smee.io to forward webhooks to your local machine.
-
-8. Go back to your app's settings, set the following:
-
-   - Webhook URL: The URL of your app's server, or the URL of the smee.io channel.
-   - Webhook secret: The secret you generated earlier.
-
-9. Install the app by navigating to the "Install App" tab, and selecting your desired repositories.
-
----
 
 ## Usage and Tools
 
-CodiumAI pr-agent provides two types of interactions ("tools"): `"PR Reviewer"` and `"PR Q&A"`.
+**PR-Agent** provides five types of interactions ("tools"): `"PR Reviewer"`, `"PR Q&A"`, `"PR Description"`, `"PR Code Sueggestions"` and `"PR Reflect and Review"`.
 
-- The "PR Reviewer" tool automatically analyzes PRs, and provides different types of feedbacks.
+- The "PR Reviewer" tool automatically analyzes PRs, and provides various types of feedback.
 - The "PR Q&A" tool answers free-text questions about the PR.
-
+- The "PR Description" tool automatically sets the PR Title and body.
-### PR Reviewer
+- The "PR Code Suggestion" tool provide inline code suggestions for the PR that can be applied and committed.
-
+- 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.
-Here is a quick overview of the different sub-tools of PR Reviewer:
-
-- PR Analysis
-  - Summarize main theme
-  - PR description and title
-  - PR type classification
-  - Is the PR covered by relevant tests
-  - Is this a focused PR
-  - Are there security concerns
-- PR Feedback
-  - General PR suggestions
-  - Code suggestions
-
-This is how a typical output of the PR Reviewer looks like:
-
----
-
-#### PR Analysis
-
-- 🎯 **Main theme:** Adding language extension handler and token handler
-- 🔍 **Description and title:** Yes
-- 📌 **Type of PR:** Enhancement
-- 🧪 **Relevant tests added:** No
-- ✨ **Focused PR:** Yes, the PR is focused on adding two new handlers for language extension and token counting.
-- 🔒 **Security concerns:** No, the PR does not introduce possible security concerns or issues.
-
-#### PR Feedback
-
-- 💡 **General PR suggestions:** The PR is generally well-structured and the code is clean. However, it would be beneficial to add some tests to ensure the new handlers work as expected. Also, consider adding docstrings to the new functions and classes to improve code readability and maintainability.
-
-- 🤖 **Code suggestions:**
-
-  - **relevant file:** pr_agent/algo/language_handler.py
-
-    **suggestion content:** Consider using a set instead of a list for 'bad_extensions' as checking membership in a set is faster than in a list. [medium]
-
-  - **relevant file:** pr_agent/algo/language_handler.py
-
-    **suggestion content:** In the 'filter_bad_extensions' function, you are splitting the filename on '.' and taking the last element to get the extension. This might not work as expected if the filename contains multiple '.' characters. Consider using 'os.path.splitext' to get the file extension more reliably. [important]
-
----
-
-### PR Q&A
-
-This tool answers free-text questions about the PR. This is how a typical output of the PR Q&A looks like:
-
-**Question**: summarize for me the PR in 4 bullet points
-
-**Answer**:
-
-- The PR introduces a new feature to sort files by their main languages. It uses a mapping of programming languages to their file extensions to achieve this.
-- It also introduces a filter to exclude files with certain extensions, deemed as 'bad extensions', from the sorting process.
-- The PR modifies the `get_pr_diff` function in `pr_processing.py` to use the new sorting function. It also refactors the code to move the PR pruning logic into a separate function.
-- A new `TokenHandler` class is introduced in `token_handler.py` to handle token counting operations. This class is initialized with a PR, variables, system, and user, and provides methods to get system and user tokens and to count tokens in a patch.
-
----
-
-## Configuration
-
-The different tools and sub-tools used by CodiumAI pr-agent are easily configurable via the configuration file: `/settings/configuration.toml`.
-
-#### Enabling/disabling sub-tools:
-
-You can enable/disable the different PR Reviewer sub-sections with the following flags:
-
-```
-require_focused_review=true
-require_tests_review=true
-require_security_review=true
-```
-
-#### Code Suggestions configuration:
-
-There are also configuration options to control different aspects of the `code suggestions` feature.
-The number of suggestions provided can be controlled by adjusting the following parameter:
-
-```
-num_code_suggestions=4
-```
-
-You can also enable more verbose and informative mode of code suggestions:
-
-```
-extended_code_suggestions=false
-```
-
-This is a comparison of the regular and extended code suggestions modes:
-
-- **relevant file:** sql.py
-- **suggestion content:** Remove hardcoded sensitive information like username and password. Use environment variables or a secure method to store these values. [important]
-
-Example for extended suggestion:
-
-- **relevant file:** sql.py
-- **suggestion content:** Remove hardcoded sensitive information (username and password) [important]
-- **why:** Hardcoding sensitive information is a security risk. It's better to use environment variables or a secure way to store these values.
-- **code example:**
-  - **before code:**
-    ```
-    user = "root",
-    password = "Mysql@123",
-    ```
-  - **after code:**
-    ```
-    user = os.getenv('DB_USER'),
-    password = os.getenv('DB_PASSWORD'),
-    ```
-
----
 
 ## How it works
 
-![PR-Agent Tools](./pics/pr_agent_overview.png)
+![PR-Agent Tools](https://www.codium.ai/wp-content/uploads/2023/07/codiumai-diagram-v4.jpg)
 
 Check out the [PR Compression strategy](./PR_COMPRESSION.md) page for more details on how we convert a code diff to a manageable LLM prompt
 
+## Why use PR-Agent?
+
+A reasonable question that can be asked is: `"Why use PR-Agent? What make it stand out from existing tools?"`
+
+Here are some of the reasons why:
+
+- We emphasize **real-life practical usage**. Each tool (review, improve, ask, ...) has a single GPT-4 call, no more. We feel that this is critical for realistic team usage - obtaining an answer quickly (~30 seconds) and affordably.
+- Our [PR Compression strategy](./PR_COMPRESSION.md)  is a core ability that enables to effectively tackle both short and long PRs.
+- Our JSON prompting strategy enables to have **modular, customizable tools**. For example, the '/review' tool categories can be controlled via the configuration file. Adding additional categories is easy and accessible.
+- We support **multiple git providers** (GitHub, Gitlab, Bitbucket), and multiple ways to use the tool (CLI, GitHub Action, Docker, ...).
+- We are open-source, and welcome contributions from the community.
+
+
 ## Roadmap
 
-- [ ] Support open-source models, as a replacement for openai models. Note that 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)
-- [ ] Support other Git providers, such as Gitlab and Bitbucket.
+- [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
-- [ ] Dedicated tools and sub-tools for specific programming languages (Python, Javascript, Java, C++, etc)
 - [ ] 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:
-  - [ ] Code Quality
+  - [x] PR description
-  - [ ] Coding Style
+  - [x] Inline code suggestions
+  - [x] Reflect and review
+  - [ ] Enforcing CONTRIBUTING.md guidelines
   - [ ] Performance (are there any performance issues)
   - [ ] Documentation (is the PR properly documented)
   - [ ] Rank the PR importance
@@ -314,6 +182,6 @@ Check out the [PR Compression strategy](./PR_COMPRESSION.md) page for more detai
 
 - [CodiumAI - Meaningful tests for busy devs](https://github.com/Codium-ai/codiumai-vscode-release)
 - [Aider - GPT powered coding in your terminal](https://github.com/paul-gauthier/aider)
-- [GPT-Engineer](https://github.com/AntonOsika/gpt-engineer)
+- [openai-pr-reviewer](https://github.com/coderabbitai/openai-pr-reviewer)
 - [CodeReview BOT](https://github.com/anc95/ChatGPT-CodeReview)
 - [AI-Maintainer](https://github.com/merwanehamadi/AI-Maintainer)

action.yaml

@@ -0,0 +1,8 @@
+name: 'Codium PR Agent'
+description: 'Summarize, review and suggest improvements for pull requests'
+branding:
+  icon: 'award'
+  color: 'green'
+runs:
+  using: 'docker'
+  image: 'Dockerfile.github_action_dockerhub'

docker/Dockerfile

@@ -1,8 +1,8 @@
 FROM python:3.10 as base
 
 WORKDIR /app
-ADD requirements.txt .
+ADD pyproject.toml .
-RUN pip install -r requirements.txt && rm requirements.txt
+RUN pip install . && rm pyproject.toml
 ENV PYTHONPATH=/app
 ADD pr_agent pr_agent
 

docker/Dockerfile.lambda

@@ -0,0 +1,12 @@
+FROM public.ecr.aws/lambda/python:3.10
+
+RUN yum update -y && \
+    yum install -y gcc python3-devel && \
+    yum clean all
+
+ADD pyproject.toml .
+RUN pip install . && rm pyproject.toml
+RUN pip install mangum==0.17.0
+COPY pr_agent/ ${LAMBDA_TASK_ROOT}/pr_agent/
+
+CMD ["pr_agent.servers.serverless.serverless"]

github_action/entrypoint.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+python /app/pr_agent/servers/github_action_runner.py

pr_agent/agent/pr_agent.py

@@ -1,24 +1,36 @@
 import re
 
+from pr_agent.config_loader import settings
+from pr_agent.tools.pr_code_suggestions import PRCodeSuggestions
+from pr_agent.tools.pr_description import PRDescription
+from pr_agent.tools.pr_information_from_user import PRInformationFromUser
 from pr_agent.tools.pr_questions import PRQuestions
 from pr_agent.tools.pr_reviewer import PRReviewer
+from pr_agent.tools.pr_update_changelog import PRUpdateChangelog
 
 
 class PRAgent:
     def __init__(self):
         pass
 
-    async def handle_request(self, pr_url, request):
+    async def handle_request(self, pr_url, request) -> bool:
-        if 'please review' in request.lower() or 'review' == request.lower().strip() or len(request) == 0:
+        action, *args = request.strip().split()
-            reviewer = PRReviewer(pr_url)
+        if any(cmd == action for cmd in ["/answer"]):
-            await reviewer.review()
+            await PRReviewer(pr_url, is_answer=True).review()
-
+        elif any(cmd == action for cmd in ["/review", "/review_pr", "/reflect_and_review"]):
-        else:
+            if settings.pr_reviewer.ask_and_reflect or "/reflect_and_review" in request:
-            if "please answer" in request.lower():
+                await PRInformationFromUser(pr_url).generate_questions()
-                question = re.split(r'(?i)please answer', request)[1].strip()
-            elif request.lower().strip().startswith("answer"):
-                question = re.split(r'(?i)answer', request)[1].strip()
             else:
-                question = request
+                await PRReviewer(pr_url, args=args).review()
-            answerer = PRQuestions(pr_url, question)
+        elif any(cmd == action for cmd in ["/describe", "/describe_pr"]):
-            await answerer.answer()
+            await PRDescription(pr_url).describe()
+        elif any(cmd == action for cmd in ["/improve", "/improve_code"]):
+            await PRCodeSuggestions(pr_url).suggest()
+        elif any(cmd == action for cmd in ["/ask", "/ask_question"]):
+            await PRQuestions(pr_url, args=args).answer()
+        elif any(cmd == action for cmd in ["/update_changelog"]):
+            await PRUpdateChangelog(pr_url, args=args).update_changelog()
+        else:
+            return False
+
+        return True

pr_agent/algo/ai_handler.py

@@ -1,28 +1,65 @@
 import logging
 
 import openai
-from openai.error import APIError, Timeout, TryAgain
+from openai.error import APIError, Timeout, TryAgain, RateLimitError
 from retry import retry
 
 from pr_agent.config_loader import settings
 
-OPENAI_RETRIES=2
+OPENAI_RETRIES=5
 
 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):
                 openai.organization = settings.openai.org
+            self.deployment_id = settings.get("OPENAI.DEPLOYMENT_ID", None)
+            if settings.get("OPENAI.API_TYPE", None):
+                openai.api_type = settings.openai.api_type
+            if settings.get("OPENAI.API_VERSION", None):
+                openai.api_version = settings.openai.api_version
+            if settings.get("OPENAI.API_BASE", None):
+                openai.api_base = settings.openai.api_base
         except AttributeError as e:
             raise ValueError("OpenAI key is required") from e
 
-    @retry(exceptions=(APIError, Timeout, TryAgain, AttributeError),
+    @retry(exceptions=(APIError, Timeout, TryAgain, AttributeError, RateLimitError),
            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,
+                            deployment_id=self.deployment_id,
                             messages=[
                                 {"role": "system", "content": system},
                                 {"role": "user", "content": user}
@@ -32,8 +69,14 @@ class AiHandler:
         except (APIError, Timeout, TryAgain) as e:
             logging.error("Error during OpenAI inference: ", e)
             raise
+        except (RateLimitError) as e:
+            logging.error("Rate limit error during OpenAI inference: ", e)
+            raise
+        except (Exception) as e:
+            logging.error("Unknown error during OpenAI inference: ", e)
+            raise TryAgain from e
         if response is None or len(response.choices) == 0:
             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,11 +8,22 @@ 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
 
+    if type(original_file_str) == bytes:
+        original_file_str = original_file_str.decode('utf-8')
+
     original_lines = original_file_str.splitlines()
     patch_lines = patch_str.splitlines()
     extended_patch_lines = []
@@ -58,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
@@ -90,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
@@ -105,3 +137,84 @@ def handle_patch_deletions(patch: str, original_file_content_str: str,
                 logging.info(f"Processing file: {file_name}, hunks were deleted")
             patch = patch_new
     return patch
+
+
+def convert_to_hunks_with_lines_numbers(patch: str, file) -> str:
+    """
+    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
+887 +      line4
+888 +      line5
+889        line6
+890        line7
+...
+--old hunk--
+        line1
+        line2
+-       line3
+-       line4
+        line5
+        line6
+           ...
+    """
+    
+    patch_with_lines_str = f"## {file.filename}\n"
+    import re
+    patch_lines = patch.splitlines()
+    RE_HUNK_HEADER = re.compile(
+        r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@[ ]?(.*)")
+    new_content_lines = []
+    old_content_lines = []
+    match = None
+    start1, size1, start2, size2 = -1, -1, -1, -1
+    for line in patch_lines:
+        if 'no newline at end of file' in line.lower():
+            continue
+
+        if line.startswith('@@'):
+            match = RE_HUNK_HEADER.match(line)
+            if match and new_content_lines:  # found a new hunk, split the previous lines
+                if new_content_lines:
+                    patch_with_lines_str += '\n--new hunk--\n'
+                    for i, line_new in enumerate(new_content_lines):
+                        patch_with_lines_str += f"{start2 + i} {line_new}\n"
+                if old_content_lines:
+                    patch_with_lines_str += '--old hunk--\n'
+                    for line_old in old_content_lines:
+                        patch_with_lines_str += f"{line_old}\n"
+                new_content_lines = []
+                old_content_lines = []
+            start1, size1, start2, size2 = map(int, match.groups()[:4])
+        elif line.startswith('+'):
+            new_content_lines.append(line)
+        elif line.startswith('-'):
+            old_content_lines.append(line)
+        else:
+            new_content_lines.append(line)
+            old_content_lines.append(line)
+
+    # finishing last hunk
+    if match and new_content_lines:
+        if new_content_lines:
+            patch_with_lines_str += '\n--new hunk--\n'
+            for i, line_new in enumerate(new_content_lines):
+                patch_with_lines_str += f"{start2 + i} {line_new}\n"
+        if old_content_lines:
+            patch_with_lines_str += '\n--old hunk--\n'
+            for line_old in old_content_lines:
+                patch_with_lines_str += f"{line_old}\n"
+
+    return patch_with_lines_str.strip()

pr_agent/algo/pr_processing.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 
-import difflib
 import logging
-from typing import Any, Tuple, Union
+from typing import Tuple, Union, Callable, List
 
-from pr_agent.algo.git_patch_processing import extend_patch, handle_patch_deletions
+from github import RateLimitExceededException
+
+from pr_agent.algo import MAX_TOKENS
+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"
 
@@ -18,27 +21,47 @@ OUTPUT_BUFFER_TOKENS_SOFT_THRESHOLD = 1000
 OUTPUT_BUFFER_TOKENS_HARD_THRESHOLD = 600
 PATCH_EXTRA_LINES = 3
 
+def get_pr_diff(git_provider: GitProvider, token_handler: TokenHandler, model: str,
+                add_line_numbers_to_hunks: bool = False, disable_extra_lines: bool = False) -> str:
+    """
+    Returns a string with the diff of the pull request, applying diff minimization techniques if needed.
 
-def get_pr_diff(git_provider: Union[GithubProvider, Any], token_handler: TokenHandler) -> str:
+    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.
+        model (str): The name of the model used for tokenization.
+        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.
     """
-    Returns a string with the diff of the PR.
+
-    If needed, apply diff minimization techniques to reduce the number of tokens
+    if disable_extra_lines:
-    """
+        global PATCH_EXTRA_LINES
-    files = list(git_provider.get_diff_files())
+        PATCH_EXTRA_LINES = 0
+
+    try:
+        diff_files = list(git_provider.get_diff_files())
+    except RateLimitExceededException as e:
+        logging.error(f"Rate limit exceeded for git provider API. original message {e}")
+        raise
 
     # get pr languages
-    pr_languages = sort_files_by_main_languages(git_provider.get_languages(), files)
+    pr_languages = sort_files_by_main_languages(git_provider.get_languages(), diff_files)
 
     # generate a standard diff string, with patch extension
-    patches_extended, total_tokens = pr_generate_extended_diff(pr_languages, token_handler)
+    patches_extended, total_tokens = pr_generate_extended_diff(pr_languages, token_handler,
+                                                               add_line_numbers_to_hunks)
 
     # if we are under the limit, return the full diff
-    if total_tokens + OUTPUT_BUFFER_TOKENS_SOFT_THRESHOLD < token_handler.limit:
+    if total_tokens + OUTPUT_BUFFER_TOKENS_SOFT_THRESHOLD < MAX_TOKENS[model]:
         return "\n".join(patches_extended)
 
     # if we are over the limit, start pruning
-    patches_compressed, modified_file_names, deleted_file_names = pr_generate_compressed_diff(pr_languages,
+    patches_compressed, modified_file_names, deleted_file_names = \
-                                                                                              token_handler)
+        pr_generate_compressed_diff(pr_languages, token_handler, model, add_line_numbers_to_hunks)
+
     final_diff = "\n".join(patches_compressed)
     if modified_file_names:
         modified_list_str = MORE_MODIFIED_FILES_ + "\n".join(modified_file_names)
@@ -49,10 +72,20 @@ def get_pr_diff(git_provider: Union[GithubProvider, Any], token_handler: TokenHa
     return final_diff
 
 
-def pr_generate_extended_diff(pr_languages: list, token_handler: TokenHandler) -> \
+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 = []
@@ -72,6 +105,9 @@ def pr_generate_extended_diff(pr_languages: list, token_handler: TokenHandler) -
             extended_patch = extend_patch(original_file_content_str, patch, num_lines=PATCH_EXTRA_LINES)
             full_extended_patch = f"## {file.filename}\n\n{extended_patch}\n"
 
+            if add_line_numbers_to_hunks:
+                full_extended_patch = convert_to_hunks_with_lines_numbers(extended_patch, file)
+
             patch_tokens = token_handler.count_tokens(full_extended_patch)
             file.tokens = patch_tokens
             total_tokens += patch_tokens
@@ -80,13 +116,28 @@ def pr_generate_extended_diff(pr_languages: list, token_handler: TokenHandler) -
     return patches_extended, total_tokens
 
 
-def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler) -> Tuple[list, list, list]:
+def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler, model: str,
-    # Apply Diff Minimization techniques to reduce the number of tokens:
+                                convert_hunks_to_line_numbers: bool) -> Tuple[list, list, list]:
-    # 0. Start from the largest diff patch to smaller ones
+    """
-    # 1. Don't use extend context lines around diff
+    Generate a compressed diff string for a pull request, using diff minimization techniques to reduce the number of tokens used.
-    # 2. Minimize deleted files
+    Args:
-    # 3. Minimize deleted hunks
+        top_langs (list): A list of dictionaries representing the languages used in the pull request and their corresponding files.
-    # 4. Minimize all remaining files when you reach token limit
+        token_handler (TokenHandler): An object of the TokenHandler class used for handling tokens in the context of the pull request.
+        model (str): The model used for tokenization.
+        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 = []
@@ -114,15 +165,19 @@ def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler) ->
             deleted_files_list.append(file.filename)
             total_tokens += token_handler.count_tokens(file.filename) + 1
             continue
+
+        if convert_hunks_to_line_numbers:
+            patch = convert_to_hunks_with_lines_numbers(patch, file)
+
         new_patch_tokens = token_handler.count_tokens(patch)
 
         # Hard Stop, no more tokens
-        if total_tokens > token_handler.limit - OUTPUT_BUFFER_TOKENS_HARD_THRESHOLD:
+        if total_tokens > MAX_TOKENS[model] - OUTPUT_BUFFER_TOKENS_HARD_THRESHOLD:
             logging.warning(f"File was fully skipped, no more tokens: {file.filename}.")
             continue
 
         # If the patch is too large, just show the file name
-        if total_tokens + new_patch_tokens > token_handler.limit - OUTPUT_BUFFER_TOKENS_SOFT_THRESHOLD:
+        if total_tokens + new_patch_tokens > MAX_TOKENS[model] - OUTPUT_BUFFER_TOKENS_SOFT_THRESHOLD:
             # Current logic is to skip the patch if it's too large
             # TODO: Option for alternative logic to remove hunks from the patch to reduce the number of tokens
             #  until we meet the requirements
@@ -135,7 +190,10 @@ def pr_generate_compressed_diff(top_langs: list, token_handler: TokenHandler) ->
             continue
 
         if patch:
-            patch_final = f"## {file.filename}\n\n{patch}\n"
+            if not convert_hunks_to_line_numbers:
+                patch_final = f"## {file.filename}\n\n{patch}\n"
+            else:
+                patch_final = patch
             patches.append(patch_final)
             total_tokens += token_handler.count_tokens(patch_final)
             if settings.config.verbosity_level >= 2:
@@ -144,14 +202,16 @@ 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:
+async def retry_with_fallback_models(f: Callable):
-    if not patch:  # to Do - also add condition for file extension
+    model = settings.config.model
+    fallback_models = settings.config.fallback_models
+    if not isinstance(fallback_models, list):
+        fallback_models = [fallback_models]
+    all_models = [model] + fallback_models
+    for i, model in enumerate(all_models):
         try:
-            diff = difflib.unified_diff(original_file_content_str.splitlines(keepends=True),
+            return await f(model)
-                                        new_file_content_str.splitlines(keepends=True))
+        except Exception as e:
-            if settings.config.verbosity_level >= 2:
+            logging.warning(f"Failed to generate prediction with {model}: {e}")
-                logging.warning(f"File was modified, but no patch was found. Manually creating patch: {file.filename}.")
+            if i == len(all_models) - 1:  # If it's the last iteration
-            patch = ''.join(diff)
+                raise  # Re-raise the last exception
-        except Exception:
-            pass
-    return patch

pr_agent/algo/token_handler.py

@@ -6,12 +6,42 @@ 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 +51,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,21 +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": "🎯",
-        "Description and title": "🔍",
         "Type of PR": "📌",
+        "Score": "🏅",
         "Relevant tests added": "🧪",
         "Unrelated changes": "⚠️",
         "Focused PR": "✨",
         "Security concerns": "🔒",
         "General PR suggestions": "💡",
-        "Code suggestions": "🤖"
+        "Insights from user's answers": "📝",
+        "Code suggestions": "🤖",
     }
 
     for key, value in output_data.items():
@@ -27,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':
@@ -35,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"
@@ -50,10 +74,7 @@ def parse_code_suggestion(code_suggestions: dict) -> str:
                 code_str_indented = textwrap.indent(code_str, '        ')
                 markdown_text += f"    - **{code_key}:**\n{code_str_indented}\n"
         else:
-            if "suggestion number" in sub_key.lower():
+            if "relevant file" in sub_key.lower():
-                # markdown_text += f"- **suggestion {sub_value}:**\n"  # prettier formatting
-                pass
-            elif "relevant file" in sub_key.lower():
                 markdown_text += f"\n  - **{sub_key}:** {sub_value}\n"
             else:
                 markdown_text += f"   **{sub_key}:** {sub_value}\n"
@@ -61,3 +82,132 @@ def parse_code_suggestion(code_suggestions: dict) -> str:
     markdown_text += "\n"
     return markdown_text
 
+
+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)
+
+    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)
+                valid_json = True
+                review = review[:last_code_suggestion_ind].strip() + closing_bracket
+            except json.decoder.JSONDecodeError:
+                review = review[:last_code_suggestion_ind]
+                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:
+        # Find the offending character index:
+        idx_to_replace = int(str(e).split(' ')[-1].replace(')', ''))
+        # Remove the offending character:
+        json_message = list(json_message)
+        json_message[idx_to_replace] = ' '
+        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

@@ -3,25 +3,107 @@ import asyncio
 import logging
 import os
 
+from pr_agent.tools.pr_code_suggestions import PRCodeSuggestions
+from pr_agent.tools.pr_description import PRDescription
+from pr_agent.tools.pr_information_from_user import PRInformationFromUser
 from pr_agent.tools.pr_questions import PRQuestions
 from pr_agent.tools.pr_reviewer import PRReviewer
+from pr_agent.tools.pr_update_changelog import PRUpdateChangelog
 
 
-def run():
+def run(args=None):
-    parser = argparse.ArgumentParser(description='AI based pull request analyzer')
+    parser = argparse.ArgumentParser(description='AI based pull request analyzer', usage=
+"""\
+Usage: cli.py --pr-url <URL on supported git hosting service> <command> [<args>].
+For example:
+- cli.py --pr-url=... review
+- cli.py --pr-url=... describe
+- cli.py --pr-url=... improve
+- cli.py --pr-url=... ask "write me a poem about this PR"
+- cli.py --pr-url=... reflect
+
+Supported commands:
+review / review_pr - Add a review that includes a summary of the PR and specific suggestions for improvement.
+ask / ask_question [question] - Ask a question about the PR.
+describe / describe_pr - Modify the PR title and description based on the PR's contents.
+improve / improve_code - Suggest improvements to the code in the PR as pull request comments ready to commit.
+reflect - Ask the PR author questions about the PR.
+update_changelog - Update the changelog based on the PR's contents.
+""")
     parser.add_argument('--pr_url', type=str, help='The URL of the PR to review', required=True)
-    parser.add_argument('--question', type=str, help='Optional question to ask', required=False)
+    parser.add_argument('command', type=str, help='The', choices=['review', 'review_pr',
-    args = parser.parse_args()
+                                                                  'ask', 'ask_question',
+                                                                  'describe', 'describe_pr',
+                                                                  'improve', 'improve_code',
+                                                                  'reflect', 'review_after_reflect',
+                                                                   'update_changelog'],
+                                                                   default='review')
+    parser.add_argument('rest', nargs=argparse.REMAINDER, default=[])
+    args = parser.parse_args(args)
     logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
-    if args.question:
+    command = args.command.lower()
-        print(f"Question: {args.question} about PR {args.pr_url}")
+    commands = {
-        reviewer = PRQuestions(args.pr_url, args.question, installation_id=None)
+        'ask': _handle_ask_command,
-        asyncio.run(reviewer.answer())
+        'ask_question': _handle_ask_command,
+        'describe': _handle_describe_command,
+        'describe_pr': _handle_describe_command,
+        'improve': _handle_improve_command,
+        'improve_code': _handle_improve_command,
+        'review': _handle_review_command,
+        'review_pr': _handle_review_command,
+        'reflect': _handle_reflect_command,
+        'review_after_reflect': _handle_review_after_reflect_command,
+        'update_changelog': _handle_update_changelog,
+    }
+    if command in commands:
+        commands[command](args.pr_url, args.rest)
     else:
-        print(f"Reviewing PR: {args.pr_url}")
+        print(f"Unknown command: {command}")
-        reviewer = PRReviewer(args.pr_url, installation_id=None, cli_mode=True)
+        parser.print_help()
-        asyncio.run(reviewer.review())
 
 
+def _handle_ask_command(pr_url: str, rest: list):
+    if len(rest) == 0:
+        print("Please specify a question")
+        return
+    print(f"Question: {' '.join(rest)} about PR {pr_url}")
+    reviewer = PRQuestions(pr_url, rest)
+    asyncio.run(reviewer.answer())
+
+
+def _handle_describe_command(pr_url: str, rest: list):
+    print(f"PR description: {pr_url}")
+    reviewer = PRDescription(pr_url)
+    asyncio.run(reviewer.describe())
+
+
+def _handle_improve_command(pr_url: str, rest: list):
+    print(f"PR code suggestions: {pr_url}")
+    reviewer = PRCodeSuggestions(pr_url)
+    asyncio.run(reviewer.suggest())
+
+
+def _handle_review_command(pr_url: str, rest: list):
+    print(f"Reviewing PR: {pr_url}")
+    reviewer = PRReviewer(pr_url, cli_mode=True, args=rest)
+    asyncio.run(reviewer.review())
+
+
+def _handle_reflect_command(pr_url: str, rest: list):
+    print(f"Asking the PR author questions: {pr_url}")
+    reviewer = PRInformationFromUser(pr_url)
+    asyncio.run(reviewer.generate_questions())
+
+
+def _handle_review_after_reflect_command(pr_url: str, rest: list):
+    print(f"Processing author's answers and sending review: {pr_url}")
+    reviewer = PRReviewer(pr_url, cli_mode=True, is_answer=True)
+    asyncio.run(reviewer.review())
+
+def _handle_update_changelog(pr_url: str, rest: list):
+    print(f"Updating changlog for: {pr_url}")
+    reviewer = PRUpdateChangelog(pr_url, cli_mode=True, args=rest)
+    asyncio.run(reviewer.update_changelog())
+
 if __name__ == '__main__':
     run()

pr_agent/config_loader.py

@@ -1,7 +1,11 @@
 from os.path import abspath, dirname, join
+from pathlib import Path
+from typing import Optional
 
 from dynaconf import Dynaconf
 
+PR_AGENT_TOML_KEY = 'pr-agent'
+
 current_dir = dirname(abspath(__file__))
 settings = Dynaconf(
     envvar_prefix=False,
@@ -9,8 +13,42 @@ settings = Dynaconf(
     settings_files=[join(current_dir, f) for f in [
          "settings/.secrets.toml",
          "settings/configuration.toml",
+         "settings/language_extensions.toml",
          "settings/pr_reviewer_prompts.toml",
          "settings/pr_questions_prompts.toml",
+         "settings/pr_description_prompts.toml",
+         "settings/pr_code_suggestions_prompts.toml",
+         "settings/pr_information_from_user_prompts.toml",
+         "settings/pr_update_changelog.toml",
          "settings_prod/.secrets.toml"
         ]]
 )
+
+
+# Add local configuration from pyproject.toml of the project being reviewed
+def _find_repository_root() -> Path:
+    """
+    Identify project root directory by recursively searching for the .git directory in the parent directories.
+    """
+    cwd = Path.cwd().resolve()
+    no_way_up = False
+    while not no_way_up:
+        no_way_up = cwd == cwd.parent
+        if (cwd / ".git").is_dir():
+            return cwd
+        cwd = cwd.parent
+    return None
+
+def _find_pyproject() -> Optional[Path]:
+    """
+    Search for file pyproject.toml in the repository root.
+    """
+    repo_root = _find_repository_root()
+    if repo_root:
+        pyproject = _find_repository_root() / "pyproject.toml"
+        return pyproject if pyproject.is_file() else None
+    return None
+
+pyproject_path = _find_pyproject()
+if pyproject_path is not None:
+    settings.load_file(pyproject_path, env=f'tool.{PR_AGENT_TOML_KEY}')

pr_agent/git_providers/__init__.py

@@ -1,10 +1,14 @@
 from pr_agent.config_loader import settings
+from pr_agent.git_providers.bitbucket_provider import BitbucketProvider
 from pr_agent.git_providers.github_provider import GithubProvider
 from pr_agent.git_providers.gitlab_provider import GitLabProvider
+from pr_agent.git_providers.local_git_provider import LocalGitProvider
 
 _GIT_PROVIDERS = {
     'github': GithubProvider,
     'gitlab': GitLabProvider,
+    'bitbucket': BitbucketProvider,
+    'local' : LocalGitProvider
 }
 
 def get_git_provider():

pr_agent/git_providers/bitbucket_provider.py

@@ -0,0 +1,123 @@
+import logging
+from typing import Optional, Tuple
+from urllib.parse import urlparse
+
+import requests
+from atlassian.bitbucket import Cloud
+
+from pr_agent.config_loader import settings
+
+from .git_provider import FilePatchInfo
+
+
+class BitbucketProvider:
+    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)
+
+        self.workspace_slug = None
+        self.repo_slug = None
+        self.repo = None
+        self.pr_num = None
+        self.pr = None
+        self.temp_comments = []
+        self.incremental = incremental
+        if pr_url:
+            self.set_pr(pr_url)
+
+    def is_supported(self, capability: str) -> bool:
+        if capability in ['get_issue_comments', 'create_inline_comment', 'publish_inline_comments', 'get_labels']:
+            return False
+        return True
+
+    def set_pr(self, pr_url: str):
+        self.workspace_slug, self.repo_slug, self.pr_num = self._parse_pr_url(pr_url)
+        self.pr = self._get_pr()
+
+    def get_files(self):
+        return [diff.new.path for diff in self.pr.diffstat()]
+
+    def get_diff_files(self) -> list[FilePatchInfo]:
+        diffs = self.pr.diffstat()
+        diff_split = ['diff --git%s' % x for x in self.pr.diff().split('diff --git') if x.strip()]
+        
+        diff_files = []
+        for index, diff in enumerate(diffs):
+            original_file_content_str = self._get_pr_file_content(diff.old.get_data('links'))
+            new_file_content_str = self._get_pr_file_content(diff.new.get_data('links'))
+            diff_files.append(FilePatchInfo(original_file_content_str, new_file_content_str,
+                                            diff_split[index], diff.new.path))
+        return diff_files
+
+    def publish_comment(self, pr_comment: str, is_temporary: bool = False):
+        comment = self.pr.comment(pr_comment)
+        if is_temporary:
+            self.temp_comments.append(comment['id'])
+
+    def remove_initial_comment(self):
+        try:
+            for comment in self.temp_comments:
+                self.pr.delete(f'comments/{comment}')
+        except Exception as e:
+            logging.exception(f"Failed to remove temp comments, error: {e}")
+
+    def publish_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        pass
+
+    def create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        raise NotImplementedError("Bitbucket provider does not support creating inline comments yet")
+
+    def publish_inline_comments(self, comments: list[dict]):
+        raise NotImplementedError("Bitbucket provider does not support publishing inline comments yet")
+
+    def get_title(self):
+        return self.pr.title
+
+    def get_languages(self):
+        languages = {self._get_repo().get_data('language'): 0}
+        return languages
+
+    def get_pr_branch(self):
+        return self.pr.source_branch
+
+    def get_pr_description(self):
+        return self.pr.description
+
+    def get_user_id(self):
+        return 0
+
+    def get_issue_comments(self):
+        raise NotImplementedError("Bitbucket provider does not support issue comments yet")
+
+    @staticmethod
+    def _parse_pr_url(pr_url: str) -> Tuple[str, int]:
+        parsed_url = urlparse(pr_url)
+        
+        if 'bitbucket.org' not in parsed_url.netloc:
+            raise ValueError("The provided URL is not a valid GitHub URL")
+
+        path_parts = parsed_url.path.strip('/').split('/')
+        
+        if len(path_parts) < 4 or path_parts[2] != 'pull-requests':
+            raise ValueError("The provided URL does not appear to be a Bitbucket PR URL")
+
+        workspace_slug = path_parts[0]
+        repo_slug = path_parts[1]
+        try:
+            pr_number = int(path_parts[3])
+        except ValueError as e:
+            raise ValueError("Unable to convert PR number to integer") from e
+
+        return workspace_slug, repo_slug, pr_number
+
+    def _get_repo(self):
+        if self.repo is None:
+            self.repo = self.bitbucket_client.workspaces.get(self.workspace_slug).repositories.get(self.repo_slug)
+        return self.repo
+
+    def _get_pr(self):
+        return self._get_repo().pullrequests.get(self.pr_num)
+
+    def _get_pr_file_content(self, remote_link: str):
+        return ""

pr_agent/git_providers/git_provider.py

@@ -1,6 +1,16 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 
+# enum EDIT_TYPE (ADDED, DELETED, MODIFIED, RENAMED)
+from enum import Enum
+
+
+class EDIT_TYPE(Enum):
+    ADDED = 1
+    DELETED = 2
+    MODIFIED = 3
+    RENAMED = 4
+
 
 @dataclass
 class FilePatchInfo:
@@ -9,17 +19,51 @@ class FilePatchInfo:
     patch: str
     filename: str
     tokens: int = -1
+    edit_type: EDIT_TYPE = EDIT_TYPE.MODIFIED
+    old_filename: str = None
 
 
 class GitProvider(ABC):
+    @abstractmethod
+    def is_supported(self, capability: str) -> bool:
+        pass
+
     @abstractmethod
     def get_diff_files(self) -> list[FilePatchInfo]:
         pass
 
+    @abstractmethod
+    def publish_description(self, pr_title: str, pr_body: str):
+        pass
+
     @abstractmethod
     def publish_comment(self, pr_comment: str, is_temporary: bool = False):
         pass
 
+    @abstractmethod
+    def publish_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        pass
+
+    @abstractmethod
+    def create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        pass
+
+    @abstractmethod
+    def publish_inline_comments(self, comments: list[dict]):
+        pass
+
+    @abstractmethod
+    def publish_code_suggestions(self, code_suggestions: list):
+        pass
+
+    @abstractmethod
+    def publish_labels(self, labels):
+        pass
+
+    @abstractmethod
+    def get_labels(self):
+        pass
+
     @abstractmethod
     def remove_initial_comment(self):
         pass
@@ -40,6 +84,10 @@ class GitProvider(ABC):
     def get_pr_description(self):
         pass
 
+    @abstractmethod
+    def get_issue_comments(self):
+        pass
+
 
 def get_main_pr_language(languages, files) -> str:
     """
@@ -80,3 +128,12 @@ 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

@@ -3,41 +3,120 @@ from datetime import datetime
 from typing import Optional, Tuple
 from urllib.parse import urlparse
 
-from github import AppAuthentication, Github
+from github import AppAuthentication, Auth, Github, GithubException
+from retry import retry
 
 from pr_agent.config_loader import settings
 
-from .git_provider import FilePatchInfo
+from ..algo.language_handler import is_valid_file
+from ..algo.utils import load_large_diff
+from .git_provider import FilePatchInfo, GitProvider, IncrementalPR
+from ..servers.utils import RateLimitExceeded
 
 
-class GithubProvider:
+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
         self.pr_num = None
         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]
+
+    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()
 
+    @retry(exceptions=RateLimitExceeded,
+           tries=settings.github.ratelimit_retries, delay=2, backoff=2, jitter=(1, 3))
     def get_diff_files(self) -> list[FilePatchInfo]:
-        files = self.pr.get_files()
+        try:
-        diff_files = []
+            files = self.get_files()
-        for file in files:
+            diff_files = []
-            original_file_content_str = self._get_pr_file_content(file, self.pr.base.sha)
+            for file in files:
-            new_file_content_str = self._get_pr_file_content(file, self.pr.head.sha)
+                if is_valid_file(file.filename):
-            diff_files.append(FilePatchInfo(original_file_content_str, new_file_content_str, file.patch, file.filename))
+                    new_file_content_str = self._get_pr_file_content(file, self.pr.head.sha)
-        return diff_files
+                    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
+        except GithubException.RateLimitExceededException as e:
+            logging.error(f"Rate limit exceeded for GitHub API. Original message: {e}")
+            raise RateLimitExceeded("Rate limit exceeded for GitHub API.") from e
+
+    def publish_description(self, pr_title: str, pr_body: str):
+        self.pr.edit(title=pr_title, body=pr_body)
+        # self.pr.create_issue_comment(pr_comment)
 
     def publish_comment(self, pr_comment: str, is_temporary: bool = False):
+        if is_temporary and not settings.config.publish_output_progress:
+            logging.debug(f"Skipping publish_comment for temporary comment: {pr_comment}")
+            return
         response = self.pr.create_issue_comment(pr_comment)
         if hasattr(response, "user") and hasattr(response.user, "login"):
             self.github_user_id = response.user.login
@@ -46,9 +125,91 @@ class GithubProvider:
             self.pr.comments_list = []
         self.pr.comments_list.append(response)
 
+    def publish_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        self.publish_inline_comments([self.create_inline_comment(body, relevant_file, relevant_line_in_file)])
+
+    def create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        self.diff_files = self.diff_files if self.diff_files else self.get_diff_files()
+        position = -1
+        for file in self.diff_files:
+            if file.filename.strip() == relevant_file:
+                patch = file.patch
+                patch_lines = patch.splitlines()
+                for i, line in enumerate(patch_lines):
+                    if relevant_line_in_file in line:
+                        position = i
+                        break
+                    elif relevant_line_in_file[0] == '+' and relevant_line_in_file[1:].lstrip() in line:
+                        # The model often adds a '+' to the beginning of the relevant_line_in_file even if originally
+                        # it's a context line
+                        position = i
+                        break
+        if position == -1:
+            if settings.config.verbosity_level >= 2:
+                logging.info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
+            subject_type = "FILE"
+        else:
+            subject_type = "LINE"
+        path = relevant_file.strip()
+        # placeholder for future API support (already supported in single inline comment)
+        # return dict(body=body, path=path, position=position, subject_type=subject_type)
+        return dict(body=body, path=path, position=position) if subject_type == "LINE" else {}
+
+    def publish_inline_comments(self, comments: list[dict]):
+        self.pr.create_review(commit=self.last_commit_id, comments=comments)
+
+    def publish_code_suggestions(self, code_suggestions: list):
+        """
+        Publishes code suggestions as comments on the PR.
+        """
+        post_parameters_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']
+
+            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
+
+            if relevant_lines_end > relevant_lines_start:
+                post_parameters = {
+                    "body": body,
+                    "path": relevant_file,
+                    "line": relevant_lines_end,
+                    "start_line": relevant_lines_start,
+                    "start_side": "RIGHT",
+                }
+            else:  # API is different for single line comments
+                post_parameters = {
+                    "body": body,
+                    "path": relevant_file,
+                    "line": relevant_lines_start,
+                    "side": "RIGHT",
+                }
+            post_parameters_list.append(post_parameters)
+
+        try:
+            self.pr.create_review(commit=self.last_commit_id, comments=post_parameters_list)
+            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:
-            for comment in self.pr.comments_list:
+            for comment in getattr(self.pr, 'comments_list', []):
                 if comment.is_temporary:
                     comment.delete()
         except Exception as e:
@@ -57,9 +218,6 @@ class GithubProvider:
     def get_title(self):
         return self.pr.title
 
-    def get_description(self):
-        return self.pr.body
-
     def get_languages(self):
         languages = self._get_repo().get_languages()
         return languages
@@ -87,6 +245,9 @@ class GithubProvider:
         notifications = self.github_client.get_user().get_notifications(since=since)
         return notifications
 
+    def get_issue_comments(self):
+        return self.pr.get_issue_comments()
+
     @staticmethod
     def _parse_pr_url(pr_url: str) -> Tuple[str, int]:
         parsed_url = urlparse(pr_url)
@@ -138,17 +299,44 @@ class GithubProvider:
                 raise ValueError(
                     "GitHub token is required when using user deployment. See: "
                     "https://github.com/Codium-ai/pr-agent#method-2-run-from-source") from e
-            return Github(token)
+            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)
 
-    def _get_pr_file_content(self, file: FilePatchInfo, sha: str):
+    def _get_pr_file_content(self, file: FilePatchInfo, sha: str) -> str:
         try:
-            file_content_str = self._get_repo().get_contents(file.filename, ref=sha).decoded_content.decode()
+            file_content_str = str(self._get_repo().get_contents(file.filename, ref=sha).decoded_content.decode())
         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 Exception as e:
+            logging.exception(f"Failed to publish labels, error: {e}")
+
+    def get_labels(self):
+        try:
+            return [label.name for label in self.pr.labels]
+        except Exception as e:
+            logging.exception(f"Failed to get labels, error: {e}")
+            return []

pr_agent/git_providers/gitlab_provider.py

@@ -1,16 +1,20 @@
 import logging
+import re
 from typing import Optional, Tuple
 from urllib.parse import urlparse
 
 import gitlab
+from gitlab import GitlabGetError
 
 from pr_agent.config_loader import settings
 
-from .git_provider import FilePatchInfo, GitProvider
+from ..algo.language_handler import is_valid_file
+from .git_provider import EDIT_TYPE, FilePatchInfo, GitProvider
 
 
 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")
@@ -18,14 +22,23 @@ class GitLabProvider(GitProvider):
         if not gitlab_access_token:
             raise ValueError("GitLab personal access token is not set in the config file")
         self.gl = gitlab.Gitlab(
-            gitlab_url,
+            url=gitlab_url,
-            gitlab_access_token
+            oauth_token=gitlab_access_token
         )
         self.id_project = None
         self.id_mr = None
         self.mr = None
+        self.diff_files = None
         self.temp_comments = []
         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']:
+            return False
+        return True
 
     @property
     def pr(self):
@@ -35,20 +48,172 @@ class GitLabProvider(GitProvider):
     def _set_merge_request(self, merge_request_url: str):
         self.id_project, self.id_mr = self._parse_merge_request_url(merge_request_url)
         self.mr = self._get_merge_request()
+        self.last_diff = self.mr.diffs.list()[-1]
+
+    def _get_pr_file_content(self, file_path: str, branch: str) -> str:
+        try:
+            return self.gl.projects.get(self.id_project).files.get(file_path, branch).decode()
+        except GitlabGetError:
+            # In case of file creation the method returns GitlabGetError (404 file not found).
+            # In this case we return an empty string for the diff.
+            return ''
 
     def get_diff_files(self) -> list[FilePatchInfo]:
         diffs = self.mr.changes()['changes']
-        diff_files = [FilePatchInfo("", "", diff['diff'], diff['new_path']) for diff in diffs]
+        diff_files = []
+        for diff in diffs:
+            if is_valid_file(diff['new_path']):
+                original_file_content_str = self._get_pr_file_content(diff['old_path'], self.mr.target_branch)
+                new_file_content_str = self._get_pr_file_content(diff['new_path'], self.mr.source_branch)
+                edit_type = EDIT_TYPE.MODIFIED
+                if diff['new_file']:
+                    edit_type = EDIT_TYPE.ADDED
+                elif diff['deleted_file']:
+                    edit_type = EDIT_TYPE.DELETED
+                elif diff['renamed_file']:
+                    edit_type = EDIT_TYPE.RENAMED
+                try:
+                    if isinstance(original_file_content_str, bytes):
+                        original_file_content_str = bytes.decode(original_file_content_str, 'utf-8')
+                    if isinstance(new_file_content_str, bytes):
+                        new_file_content_str = bytes.decode(new_file_content_str, 'utf-8')
+                except UnicodeDecodeError:
+                    logging.warning(
+                        f"Cannot decode file {diff['old_path']} or {diff['new_path']} in merge request {self.id_mr}")
+                diff_files.append(
+                    FilePatchInfo(original_file_content_str, new_file_content_str, diff['diff'], diff['new_path'],
+                                  edit_type=edit_type,
+                                  old_filename=None if diff['old_path'] == diff['new_path'] else diff['old_path']))
+        self.diff_files = diff_files
         return diff_files
 
     def get_files(self):
         return [change['new_path'] for change in self.mr.changes()['changes']]
 
+    def publish_description(self, pr_title: str, pr_body: str):
+        try:
+            self.mr.title = pr_title
+            self.mr.description = pr_body
+            self.mr.save()
+        except Exception as e:
+            logging.exception(f"Could not update merge request {self.id_mr} description: {e}")
+
     def publish_comment(self, mr_comment: str, is_temporary: bool = False):
         comment = self.mr.notes.create({'body': mr_comment})
         if is_temporary:
             self.temp_comments.append(comment)
 
+    def publish_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        self.diff_files = self.diff_files if self.diff_files else self.get_diff_files()
+        edit_type, found, source_line_no, target_file, target_line_no = self.search_line(relevant_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 create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        raise NotImplementedError("Gitlab provider does not support creating inline comments yet")
+
+    def create_inline_comments(self, comments: list[dict]):
+        raise NotImplementedError("Gitlab provider does not support publishing inline comments yet")
+
+    def send_inline_comment(self, body, edit_type, found, relevant_file, relevant_line_in_file, source_line_no,
+                            target_file, target_line_no):
+        if not found:
+            logging.info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
+        else:
+            d = self.last_diff
+            pos_obj = {'position_type': 'text',
+                       'new_path': target_file.filename,
+                       'old_path': target_file.old_filename if target_file.old_filename else target_file.filename,
+                       'base_sha': d.base_commit_sha, 'start_sha': d.start_commit_sha, 'head_sha': d.head_commit_sha}
+            if edit_type == 'deletion':
+                pos_obj['old_line'] = source_line_no - 1
+            elif edit_type == 'addition':
+                pos_obj['new_line'] = target_line_no - 1
+            else:
+                pos_obj['new_line'] = target_line_no - 1
+                pos_obj['old_line'] = source_line_no - 1
+            self.mr.discussions.create({'body': body,
+                                        'position': pos_obj})
+
+    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']
+
+            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
+
+        edit_type = self.get_edit_type(relevant_line_in_file)
+        for file in self.diff_files:
+            if file.filename == relevant_file:
+                edit_type, found, source_line_no, target_file, target_line_no = self.find_in_file(file,
+                                                                                                  relevant_line_in_file)
+        return edit_type, found, source_line_no, target_file, target_line_no
+
+    def find_in_file(self, file, relevant_line_in_file):
+        edit_type = 'context'
+        source_line_no = 0
+        target_line_no = 0
+        found = False
+        target_file = file
+        patch = file.patch
+        patch_lines = patch.splitlines()
+        for line in patch_lines:
+            if line.startswith('@@'):
+                match = self.RE_HUNK_HEADER.match(line)
+                if not match:
+                    continue
+                start_old, size_old, start_new, size_new, _ = match.groups()
+                source_line_no = int(start_old)
+                target_line_no = int(start_new)
+                continue
+            if line.startswith('-'):
+                source_line_no += 1
+            elif line.startswith('+'):
+                target_line_no += 1
+            elif line.startswith(' '):
+                source_line_no += 1
+                target_line_no += 1
+            if relevant_line_in_file in line:
+                found = True
+                edit_type = self.get_edit_type(line)
+                break
+            elif relevant_line_in_file[0] == '+' and relevant_line_in_file[1:].lstrip() in line:
+                # The model often adds a '+' to the beginning of the relevant_line_in_file even if originally
+                # it's a context line
+                found = True
+                edit_type = self.get_edit_type(line)
+                break
+        return edit_type, found, source_line_no, target_file, target_line_no
+
+    def get_edit_type(self, relevant_line_in_file):
+        edit_type = 'context'
+        if relevant_line_in_file[0] == '-':
+            edit_type = 'deletion'
+        elif relevant_line_in_file[0] == '+':
+            edit_type = 'addition'
+        return edit_type
+
     def remove_initial_comment(self):
         try:
             for comment in self.temp_comments:
@@ -59,9 +224,6 @@ class GitLabProvider(GitProvider):
     def get_title(self):
         return self.mr.title
 
-    def get_description(self):
-        return self.mr.description
-
     def get_languages(self):
         languages = self.gl.projects.get(self.id_project).languages()
         return languages
@@ -72,21 +234,50 @@ class GitLabProvider(GitProvider):
     def get_pr_description(self):
         return self.mr.description
 
-    def _parse_merge_request_url(self, merge_request_url: str) -> Tuple[int, int]:
+    def get_issue_comments(self):
+        raise NotImplementedError("GitLab provider does not support issue comments yet")
+
+    def _parse_merge_request_url(self, merge_request_url: str) -> Tuple[str, int]:
         parsed_url = urlparse(merge_request_url)
 
         path_parts = parsed_url.path.strip('/').split('/')
-        if path_parts[-2] != 'merge_requests':
+        if 'merge_requests' not in path_parts:
             raise ValueError("The provided URL does not appear to be a GitLab merge request URL")
 
+        mr_index = path_parts.index('merge_requests')
+        # Ensure there is an ID after 'merge_requests'
+        if len(path_parts) <= mr_index + 1:
+            raise ValueError("The provided URL does not contain a merge request ID")
+
         try:
-            mr_id = int(path_parts[-1])
+            mr_id = int(path_parts[mr_index + 1])
         except ValueError as e:
             raise ValueError("Unable to convert merge request ID to integer") from e
 
-        # Gitlab supports access by both project numeric ID as well as 'namespace/project_name'
+        # Handle special delimiter (-)
-        return "/".join(path_parts[:2]), mr_id
+        project_path = "/".join(path_parts[:mr_index])
+        if project_path.endswith('/-'):
+            project_path = project_path[:-2]
+
+        # Return the path before 'merge_requests' and the ID
+        return project_path, mr_id
 
     def _get_merge_request(self):
         mr = self.gl.projects.get(self.id_project).mergerequests.get(self.id_mr)
         return mr
+
+    def get_user_id(self):
+        return None
+
+    def publish_labels(self, pr_types):
+        try:
+            self.mr.labels = list(set(pr_types))
+            self.mr.save()
+        except Exception as e:
+            logging.exception(f"Failed to publish labels, error: {e}")
+
+    def publish_inline_comments(self, comments: list[dict]):
+        pass
+
+    def get_labels(self):
+        return self.mr.labels

pr_agent/git_providers/local_git_provider.py

@@ -0,0 +1,178 @@
+import logging
+from collections import Counter
+from pathlib import Path
+from typing import List
+
+from git import Repo
+
+from pr_agent.config_loader import _find_repository_root, settings
+from pr_agent.git_providers.git_provider import EDIT_TYPE, FilePatchInfo, GitProvider
+
+
+class PullRequestMimic:
+    """
+    This class mimics the PullRequest class from the PyGithub library for the LocalGitProvider.
+    """
+
+    def __init__(self, title: str, diff_files: List[FilePatchInfo]):
+        self.title = title
+        self.diff_files = diff_files
+
+
+class LocalGitProvider(GitProvider):
+    """
+    This class implements the GitProvider interface for local git repositories.
+    It mimics the PR functionality of the GitProvider interface,
+    but does not require a hosted git repository.
+    Instead of providing a PR url, the user provides a local branch path to generate a diff-patch.
+    For the MVP it only supports the /review and /describe capabilities.
+    """
+
+    def __init__(self, target_branch_name, incremental=False):
+        self.repo_path = _find_repository_root()
+        if self.repo_path is None:
+            raise ValueError('Could not find repository root')
+        self.repo = Repo(self.repo_path)
+        self.head_branch_name = self.repo.head.ref.name
+        self.target_branch_name = target_branch_name
+        self._prepare_repo()
+        self.diff_files = None
+        self.pr = PullRequestMimic(self.get_pr_title(), self.get_diff_files())
+        self.description_path = settings.get('local.description_path') \
+            if settings.get('local.description_path') is not None else self.repo_path / 'description.md'
+        self.review_path = settings.get('local.review_path') \
+            if settings.get('local.review_path') is not None else self.repo_path / 'review.md'
+        # inline code comments are not supported for local git repositories
+        settings.pr_reviewer.inline_code_comments = False
+
+    def _prepare_repo(self):
+        """
+        Prepare the repository for PR-mimic generation.
+        """
+        logging.debug('Preparing repository for PR-mimic generation...')
+        if self.repo.is_dirty():
+            raise ValueError('The repository is not in a clean state. Please commit or stash pending changes.')
+        if self.target_branch_name not in self.repo.heads:
+            raise KeyError(f'Branch: {self.target_branch_name} does not exist')
+
+    def is_supported(self, capability: str) -> bool:
+        if capability in ['get_issue_comments', 'create_inline_comment', 'publish_inline_comments', 'get_labels']:
+            return False
+        return True
+
+    def get_diff_files(self) -> list[FilePatchInfo]:
+        diffs = self.repo.head.commit.diff(
+            self.repo.merge_base(self.repo.head, self.repo.branches[self.target_branch_name]),
+            create_patch=True,
+            R=True
+        )
+        diff_files = []
+        for diff_item in diffs:
+            if diff_item.a_blob is not None:
+                original_file_content_str = diff_item.a_blob.data_stream.read().decode('utf-8')
+            else:
+                original_file_content_str = ""  # empty file
+            if diff_item.b_blob is not None:
+                new_file_content_str = diff_item.b_blob.data_stream.read().decode('utf-8')
+            else:
+                new_file_content_str = ""  # empty file
+            edit_type = EDIT_TYPE.MODIFIED
+            if diff_item.new_file:
+                edit_type = EDIT_TYPE.ADDED
+            elif diff_item.deleted_file:
+                edit_type = EDIT_TYPE.DELETED
+            elif diff_item.renamed_file:
+                edit_type = EDIT_TYPE.RENAMED
+            diff_files.append(
+                FilePatchInfo(original_file_content_str,
+                              new_file_content_str,
+                              diff_item.diff.decode('utf-8'),
+                              diff_item.b_path,
+                              edit_type=edit_type,
+                              old_filename=None if diff_item.a_path == diff_item.b_path else diff_item.a_path
+                              )
+            )
+        self.diff_files = diff_files
+        return diff_files
+
+    def get_files(self) -> List[str]:
+        """
+        Returns a list of files with changes in the diff.
+        """
+        diff_index = self.repo.head.commit.diff(
+            self.repo.merge_base(self.repo.head, self.repo.branches[self.target_branch_name]),
+            R=True
+        )
+        # Get the list of changed files
+        diff_files = [item.a_path for item in diff_index]
+        return diff_files
+
+    def publish_description(self, pr_title: str, pr_body: str):
+        with open(self.description_path, "w") as file:
+            # Write the string to the file
+            file.write(pr_title + '\n' + pr_body)
+
+    def publish_comment(self, pr_comment: str, is_temporary: bool = False):
+        with open(self.review_path, "w") as file:
+            # Write the string to the file
+            file.write(pr_comment)
+
+    def publish_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        raise NotImplementedError('Publishing inline comments is not implemented for the local git provider')
+
+    def create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        raise NotImplementedError('Creating inline comments is not implemented for the local git provider')
+
+    def publish_inline_comments(self, comments: list[dict]):
+        raise NotImplementedError('Publishing inline comments is not implemented for the local git provider')
+
+    def publish_code_suggestion(self, body: str, relevant_file: str,
+                                relevant_lines_start: int, relevant_lines_end: int):
+        raise NotImplementedError('Publishing code suggestions is not implemented for the local git provider')
+
+    def publish_code_suggestions(self, code_suggestions: list):
+        raise NotImplementedError('Publishing code suggestions is not implemented for the local git provider')
+
+    def publish_labels(self, labels):
+        pass  # Not applicable to the local git provider, but required by the interface
+
+    def remove_initial_comment(self):
+        pass  # Not applicable to the local git provider, but required by the interface
+
+    def get_languages(self):
+        """
+        Calculate percentage of languages in repository. Used for hunk prioritisation.
+        """
+        # Get all files in repository
+        filepaths = [Path(item.path) for item in self.repo.tree().traverse() if item.type == 'blob']
+        # Identify language by file extension and count
+        lang_count = Counter(ext.lstrip('.') for filepath in filepaths for ext in [filepath.suffix.lower()])
+        # Convert counts to percentages
+        total_files = len(filepaths)
+        lang_percentage = {lang: count / total_files * 100 for lang, count in lang_count.items()}
+        return lang_percentage
+
+    def get_pr_branch(self):
+        return self.repo.head
+
+    def get_user_id(self):
+        return -1  # Not used anywhere for the local provider, but required by the interface
+
+    def get_pr_description(self):
+        commits_diff = list(self.repo.iter_commits(self.target_branch_name + '..HEAD'))
+        # Get the commit messages and concatenate
+        commit_messages = " ".join([commit.message for commit in commits_diff])
+        # TODO Handle the description better - maybe use gpt-3.5 summarisation here?
+        return commit_messages[:200]  # Use max 200 characters
+
+    def get_pr_title(self):
+        """
+        Substitutes the branch-name as the PR-mimic title.
+        """
+        return self.head_branch_name
+
+    def get_issue_comments(self):
+        raise NotImplementedError('Getting issue comments is not implemented for the local git provider')
+
+    def get_labels(self):
+        raise NotImplementedError('Getting labels is not implemented for the local git provider')

pr_agent/servers/github_action_runner.py

@@ -0,0 +1,68 @@
+import asyncio
+import json
+import os
+
+from pr_agent.agent.pr_agent import PRAgent
+from pr_agent.config_loader import settings
+from pr_agent.tools.pr_reviewer import PRReviewer
+
+
+async def run_action():
+    # Get environment variables
+    GITHUB_EVENT_NAME = os.environ.get('GITHUB_EVENT_NAME')
+    GITHUB_EVENT_PATH = os.environ.get('GITHUB_EVENT_PATH')
+    OPENAI_KEY = os.environ.get('OPENAI_KEY')
+    OPENAI_ORG = os.environ.get('OPENAI_ORG')
+    GITHUB_TOKEN = os.environ.get('GITHUB_TOKEN')
+
+    # Check if required environment variables are set
+    if not GITHUB_EVENT_NAME:
+        print("GITHUB_EVENT_NAME not set")
+        return
+    if not GITHUB_EVENT_PATH:
+        print("GITHUB_EVENT_PATH not set")
+        return
+    if not OPENAI_KEY:
+        print("OPENAI_KEY not set")
+        return
+    if not GITHUB_TOKEN:
+        print("GITHUB_TOKEN not set")
+        return
+
+    # Set the environment variables in the settings
+    settings.set("OPENAI.KEY", OPENAI_KEY)
+    if OPENAI_ORG:
+        settings.set("OPENAI.ORG", OPENAI_ORG)
+    settings.set("GITHUB.USER_TOKEN", GITHUB_TOKEN)
+    settings.set("GITHUB.DEPLOYMENT_TYPE", "user")
+
+    # Load the event payload
+    try:
+        with open(GITHUB_EVENT_PATH, 'r') as f:
+            event_payload = json.load(f)
+    except json.decoder.JSONDecodeError as e:
+        print(f"Failed to parse JSON: {e}")
+        return
+
+    # Handle pull request event
+    if GITHUB_EVENT_NAME == "pull_request":
+        action = event_payload.get("action")
+        if action in ["opened", "reopened"]:
+            pr_url = event_payload.get("pull_request", {}).get("url")
+            if pr_url:
+                await PRReviewer(pr_url).review()
+
+    # Handle issue comment event
+    elif GITHUB_EVENT_NAME == "issue_comment":
+        action = event_payload.get("action")
+        if action in ["created", "edited"]:
+            comment_body = event_payload.get("comment", {}).get("body")
+            if comment_body:
+                pr_url = event_payload.get("issue", {}).get("pull_request", {}).get("url")
+                if pr_url:
+                    body = comment_body.strip().lower()
+                    await PRAgent().handle_request(pr_url, body)
+
+
+if __name__ == '__main__':
+    asyncio.run(run_action())

pr_agent/servers/github_app.py

@@ -1,3 +1,4 @@
+from typing import Dict, Any
 import logging
 import sys
 
@@ -14,51 +15,66 @@ router = APIRouter()
 
 @router.post("/api/v1/github_webhooks")
 async def handle_github_webhooks(request: Request, response: Response):
-    logging.debug("Received a github webhook")
+    """
+    Receives and processes incoming GitHub webhook requests.
+    Verifies the request signature, parses the request body, and passes it to the handle_request function for further processing.
+    """
+    logging.debug("Received a GitHub webhook")
+    
     try:
         body = await request.json()
     except Exception as e:
         logging.error("Error parsing request body", e)
         raise HTTPException(status_code=400, detail="Error parsing request body") from e
+    
     body_bytes = await request.body()
     signature_header = request.headers.get('x-hub-signature-256', None)
-    try:
+    
-        webhook_secret = settings.github.webhook_secret
+    webhook_secret = getattr(settings.github, 'webhook_secret', None)
-    except AttributeError:
+    
-        webhook_secret = None
     if webhook_secret:
         verify_signature(body_bytes, webhook_secret, signature_header)
+    
     logging.debug(f'Request body:\n{body}')
+    
     return await handle_request(body)
 
 
-async def handle_request(body):
+async def handle_request(body: Dict[str, Any]):
-    action = body.get("action", None)
+    """
-    installation_id = body.get("installation", {}).get("id", None)
+    Handle incoming GitHub webhook requests.
+
+    Args:
+        body: The request body.
+    """
+    action = body.get("action")
+    installation_id = body.get("installation", {}).get("id")
     settings.set("GITHUB.INSTALLATION_ID", installation_id)
     agent = PRAgent()
+
     if action == 'created':
         if "comment" not in body:
             return {}
-        comment_body = body.get("comment", {}).get("body", None)
+        comment_body = body.get("comment", {}).get("body")
-        if 'sender' in body and 'login' in body['sender'] and 'bot' in body['sender']['login']:
+        sender = body.get("sender", {}).get("login")
+        if sender and 'bot' in sender:
             return {}
-        if "issue" not in body and "pull_request" not in body["issue"]:
+        if "issue" not in body or "pull_request" not in body["issue"]:
             return {}
         pull_request = body["issue"]["pull_request"]
-        api_url = pull_request.get("url", None)
+        api_url = pull_request.get("url")
         await agent.handle_request(api_url, comment_body)
 
     elif action in ["opened"] or 'reopened' in action:
-        pull_request = body.get("pull_request", None)
+        pull_request = body.get("pull_request")
         if not pull_request:
             return {}
-        api_url = pull_request.get("url", None)
+        api_url = pull_request.get("url")
-        if api_url is None:
+        if not api_url:
             return {}
-        await agent.handle_request(api_url, "please review")
+        await agent.handle_request(api_url, "/review")
-    else:
+
-        return {}
+    return {}
 
 
 @router.get("/")
@@ -76,4 +92,4 @@ def start():
 
 
 if __name__ == '__main__':
-    start()
+    start()

pr_agent/servers/github_polling.py

@@ -8,33 +8,47 @@ import aiohttp
 from pr_agent.agent.pr_agent import PRAgent
 from pr_agent.config_loader import settings
 from pr_agent.git_providers import get_git_provider
+from pr_agent.servers.help import bot_help_text
 
 logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
 NOTIFICATION_URL = "https://api.github.com/notifications"
 
 
 def now() -> str:
+    """
+    Get the current UTC time in ISO 8601 format.
+    
+    Returns:
+        str: The current UTC time in ISO 8601 format.
+    """
     now_utc = datetime.now(timezone.utc).isoformat()
     now_utc = now_utc.replace("+00:00", "Z")
     return now_utc
 
 
 async def polling_loop():
+    """
+    Polls for notifications and handles them accordingly.
+    """
     handled_ids = set()
     since = [now()]
     last_modified = [None]
     git_provider = get_git_provider()()
     user_id = git_provider.get_user_id()
+    agent = PRAgent()
+
     try:
         deployment_type = settings.github.deployment_type
         token = settings.github.user_token
     except AttributeError:
         deployment_type = 'none'
         token = None
+
     if deployment_type != 'user':
         raise ValueError("Deployment mode must be set to 'user' to get notifications")
     if not token:
         raise ValueError("User token must be set to get notifications")
+
     async with aiohttp.ClientSession() as session:
         while True:
             try:
@@ -50,6 +64,7 @@ async def polling_loop():
                     params["since"] = since[0]
                 if last_modified[0]:
                     headers["If-Modified-Since"] = last_modified[0]
+
                 async with session.get(NOTIFICATION_URL, headers=headers, params=params) as response:
                     if response.status == 200:
                         if 'Last-Modified' in response.headers:
@@ -83,13 +98,19 @@ async def polling_loop():
                                             if user_tag not in comment_body:
                                                 continue
                                             rest_of_comment = comment_body.split(user_tag)[1].strip()
-                                            agent = PRAgent()
+
-                                            await agent.handle_request(pr_url, rest_of_comment)
+                                            success = await agent.handle_request(pr_url, rest_of_comment)
+                                            if not success:
+                                                git_provider.set_pr(pr_url)
+                                                git_provider.publish_comment("### How to use PR-Agent\n" +
+                                                                             bot_help_text(user_id))
+
                     elif response.status != 304:
                         print(f"Failed to fetch notifications. Status code: {response.status}")
 
             except Exception as e:
                 logging.error(f"Exception during processing of a notification: {e}")
 
+
 if __name__ == '__main__':
-    asyncio.run(polling_loop())
+    asyncio.run(polling_loop())

pr_agent/servers/gitlab_polling.py

@@ -1,64 +0,0 @@
-import asyncio
-import time
-
-import gitlab
-
-from pr_agent.agent.pr_agent import PRAgent
-from pr_agent.config_loader import settings
-
-gl = gitlab.Gitlab(
-    settings.get("GITLAB.URL"),
-    private_token=settings.get("GITLAB.PERSONAL_ACCESS_TOKEN")
-)
-
-# Set the list of projects to monitor
-projects_to_monitor = settings.get("GITLAB.PROJECTS_TO_MONITOR")
-magic_word = settings.get("GITLAB.MAGIC_WORD")
-
-# Hold the previous seen comments
-previous_comments = set()
-
-
-def check_comments():
-    print('Polling')
-    new_comments = {}
-    for project in projects_to_monitor:
-        project = gl.projects.get(project)
-        merge_requests = project.mergerequests.list(state='opened')
-        for mr in merge_requests:
-            notes = mr.notes.list(get_all=True)
-            for note in notes:
-                if note.id not in previous_comments and note.body.startswith(magic_word):
-                    new_comments[note.id] = dict(
-                        body=note.body[len(magic_word):],
-                        project=project.name,
-                        mr=mr
-                    )
-                    previous_comments.add(note.id)
-                    print(f"New comment in project {project.name}, merge request {mr.title}: {note.body}")
-
-    return new_comments
-
-
-def handle_new_comments(new_comments):
-    print('Handling new comments')
-    agent = PRAgent()
-    for _, comment in new_comments.items():
-        print(f"Handling comment: {comment['body']}")
-        asyncio.run(agent.handle_request(comment['mr'].web_url, comment['body']))
-
-
-def run():
-    assert settings.get('CONFIG.GIT_PROVIDER') == 'gitlab', 'This script is only for GitLab'
-    # Initial run to populate previous_comments
-    check_comments()
-
-    # Run the check every minute
-    while True:
-        time.sleep(settings.get("GITLAB.POLLING_INTERVAL_SECONDS"))
-        new_comments = check_comments()
-        if new_comments:
-            handle_new_comments(new_comments)
-
-if __name__ == '__main__':
-    run()

pr_agent/servers/gitlab_webhook.py

@@ -0,0 +1,47 @@
+import logging
+
+import uvicorn
+from fastapi import APIRouter, FastAPI, Request, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
+from starlette.background import BackgroundTasks
+
+from pr_agent.agent.pr_agent import PRAgent
+from pr_agent.config_loader import settings
+
+app = FastAPI()
+router = APIRouter()
+
+
+@router.post("/webhook")
+async def gitlab_webhook(background_tasks: BackgroundTasks, request: Request):
+    data = await request.json()
+    if data.get('object_kind') == 'merge_request' and data['object_attributes'].get('action') in ['open', 'reopen']:
+        logging.info(f"A merge request has been opened: {data['object_attributes'].get('title')}")
+        url = data['object_attributes'].get('url')
+        background_tasks.add_task(PRAgent().handle_request, url, "/review")
+    elif data.get('object_kind') == 'note' and data['event_type'] == 'note':
+        if 'merge_request' in data:
+            mr = data['merge_request']
+            url = mr.get('url')
+            body = data.get('object_attributes', {}).get('note')
+            background_tasks.add_task(PRAgent().handle_request, url, body)
+    return JSONResponse(status_code=status.HTTP_200_OK, content=jsonable_encoder({"message": "success"}))
+
+def start():
+    gitlab_url = settings.get("GITLAB.URL", None)
+    if not gitlab_url:
+        raise ValueError("GITLAB.URL is not set")
+    gitlab_token = settings.get("GITLAB.PERSONAL_ACCESS_TOKEN", None)
+    if not gitlab_token:
+        raise ValueError("GITLAB.PERSONAL_ACCESS_TOKEN is not set")
+    settings.config.git_provider = "gitlab"
+
+    app = FastAPI()
+    app.include_router(router)
+
+    uvicorn.run(app, host="0.0.0.0", port=3000)
+
+
+if __name__ == '__main__':
+    start()

pr_agent/servers/help.py

@@ -0,0 +1,14 @@
+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"
+
+
+def bot_help_text(user: str):
+    return f"> Tag me in a comment '@{user}' and add one of the following commands:\n" + commands_text
+
+
+actions_help_text = "> To invoke the PR-Agent, add a comment using one of the following commands:\n" + \
+                    commands_text

pr_agent/servers/serverless.py

@@ -0,0 +1,18 @@
+import logging
+
+from fastapi import FastAPI
+from mangum import Mangum
+
+from pr_agent.servers.github_app import router
+
+logger = logging.getLogger()
+logger.setLevel(logging.DEBUG)
+
+app = FastAPI()
+app.include_router(router)
+
+handler = Mangum(app, lifespan="off")
+
+
+def serverless(event, context):
+    return handler(event, context)

pr_agent/servers/utils.py

@@ -21,3 +21,7 @@ def verify_signature(payload_body, secret_token, signature_header):
     if not hmac.compare_digest(expected_signature, signature_header):
         raise HTTPException(status_code=403, detail="Request signatures didn't match!")
 
+
+class RateLimitExceeded(Exception):
+    """Raised when the git provider API rate limit has been exceeded."""
+    pass

pr_agent/settings/.secrets_template.toml

@@ -9,6 +9,11 @@
 [openai]
 key = "<API_KEY>"  # Acquire through https://platform.openai.com
 org = "<ORGANIZATION>"  # Optional, may be commented out.
+# Uncomment the following for Azure OpenAI
+#api_type = "azure"
+#api_version = '2023-05-15'  # Check Azure documentation for the current API version
+#api_base = "<API_BASE>"  # The base URL for your Azure OpenAI resource. e.g. "https://<your resource name>.openai.azure.com"
+#deployment_id = "<DEPLOYMENT_ID>"  # The deployment name you chose when you deployed the engine
 
 [github]
 # ---- Set the following only for deployment type == "user"
@@ -27,3 +32,6 @@ webhook_secret = "<WEBHOOK SECRET>"  # Optional, may be commented out.
 # Gitlab personal access token
 personal_access_token = ""
 
+[bitbucket]
+# Bitbucket personal bearer token
+bearer_token = ""

pr_agent/settings/configuration.toml

@@ -1,25 +1,40 @@
 [config]
-model="gpt-4-0613"
+model="gpt-4"
+fallback_models=["gpt-3.5-turbo-16k"]
 git_provider="github"
-publish_review=true
+publish_output=true
-verbosity_level=0  # 0,1,2
+publish_output_progress=true
+verbosity_level=0 # 0,1,2
+use_extra_bad_extensions=false
 
 [pr_reviewer]
 require_focused_review=true
+require_score_review=false
 require_tests_review=true
 require_security_review=true
-extended_code_suggestions=false
+num_code_suggestions=0
-num_code_suggestions=4
+inline_code_comments = true
+ask_and_reflect=false
+
+[pr_description]
+publish_description_as_comment=false
 
 [pr_questions]
 
+[pr_code_suggestions]
+num_code_suggestions=4
+
+[pr_update_changelog]
+push_changelog_changes=false
+
 [github]
 # The type of deployment to create. Valid values are 'app' or 'user'.
 deployment_type = "user"
+ratelimit_retries = 5
 
 [gitlab]
 # URL to the gitlab service
-gitlab_url = "https://gitlab.com"
+url = "https://gitlab.com"
 
 # Polling (either project id or namespace/project_name) syntax can be used
 projects_to_monitor = ['org_name/repo_name']
@@ -29,3 +44,8 @@ magic_word = "AutoReview"
 
 # Polling interval
 polling_interval_seconds = 30
+
+[local]
+# LocalGitProvider settings - uncomment to use paths other than default
+# description_path= "path/to/description.md"
+# review_path= "path/to/review.md"

pr_agent/settings/language_extensions.toml

@@ -0,0 +1,434 @@
+[bad_extensions]
+default = [
+    'app',
+    'bin',
+    'bmp',
+    'bz2',
+    'class',
+    'csv',
+    'dat',
+    'db',
+    'dll',
+    'dylib',
+    'egg',
+    'eot',
+    'exe',
+    'gif',
+    'gitignore',
+    'glif',
+    'gradle',
+    'gz',
+    'ico',
+    'jar',
+    'jpeg',
+    'jpg',
+    'lo',
+    'lock',
+    'log',
+    'mp3',
+    'mp4',
+    'nar',
+    'o',
+    'ogg',
+    'otf',
+    'p',
+    'pdf',
+    'png',
+    'pickle',
+    'pkl',
+    'pyc',
+    'pyd',
+    'pyo',
+    'rkt',
+    'so',
+    'ss',
+    'svg',
+    'tar',
+    'tsv',
+    'ttf',
+    'war',
+    'webm',
+    'woff',
+    'woff2',
+    'xz',
+    'zip',
+    'zst',
+    'snap'
+]
+extra = [
+    'md',
+    'txt'
+]
+
+[language_extension_map_org]
+ABAP = [".abap", ]
+"AGS Script" = [".ash", ]
+AMPL = [".ampl", ]
+ANTLR = [".g4", ]
+"API Blueprint" = [".apib", ]
+APL = [".apl", ".dyalog", ]
+ASP = [".asp", ".asax", ".ascx", ".ashx", ".asmx", ".aspx", ".axd", ]
+ATS = [".dats", ".hats", ".sats", ]
+ActionScript = [".as", ]
+Ada = [".adb", ".ada", ".ads", ]
+Agda = [".agda", ]
+Alloy = [".als", ]
+ApacheConf = [".apacheconf", ".vhost", ]
+AppleScript = [".applescript", ".scpt", ]
+Arc = [".arc", ]
+Arduino = [".ino", ]
+AsciiDoc = [".asciidoc", ".adoc", ]
+AspectJ = [".aj", ]
+Assembly = [".asm", ".a51", ".nasm", ]
+Augeas = [".aug", ]
+AutoHotkey = [".ahk", ".ahkl", ]
+AutoIt = [".au3", ]
+Awk = [".awk", ".auk", ".gawk", ".mawk", ".nawk", ]
+Batchfile = [".bat", ".cmd", ]
+Befunge = [".befunge", ]
+Bison = [".bison", ]
+BitBake = [".bb", ]
+BlitzBasic = [".decls", ]
+BlitzMax = [".bmx", ]
+Bluespec = [".bsv", ]
+Boo = [".boo", ]
+Brainfuck = [".bf", ]
+Brightscript = [".brs", ]
+Bro = [".bro", ]
+C = [".c", ".cats", ".h", ".idc", ".w", ]
+"C#" = [".cs", ".cake", ".cshtml", ".csx", ]
+"C++" = [".cpp", ".c++", ".cc", ".cp", ".cxx", ".h++", ".hh", ".hpp", ".hxx", ".inl", ".ipp", ".tcc", ".tpp", ".C", ".H", ]
+C-ObjDump = [".c-objdump", ]
+"C2hs Haskell" = [".chs", ]
+CLIPS = [".clp", ]
+CMake = [".cmake", ".cmake.in", ]
+COBOL = [".cob", ".cbl", ".ccp", ".cobol", ".cpy", ]
+CSS = [".css", ]
+CSV = [".csv", ]
+"Cap'n Proto" = [".capnp", ]
+CartoCSS = [".mss", ]
+Ceylon = [".ceylon", ]
+Chapel = [".chpl", ]
+ChucK = [".ck", ]
+Cirru = [".cirru", ]
+Clarion = [".clw", ]
+Clean = [".icl", ".dcl", ]
+Click = [".click", ]
+Clojure = [".clj", ".boot", ".cl2", ".cljc", ".cljs", ".cljs.hl", ".cljscm", ".cljx", ".hic", ]
+CoffeeScript = [".coffee", "._coffee", ".cjsx", ".cson", ".iced", ]
+ColdFusion = [".cfm", ".cfml", ]
+"ColdFusion CFC" = [".cfc", ]
+"Common Lisp" = [".lisp", ".asd", ".lsp", ".ny", ".podsl", ".sexp", ]
+"Component Pascal" = [".cps", ]
+Coq = [".coq", ]
+Cpp-ObjDump = [".cppobjdump", ".c++-objdump", ".c++objdump", ".cpp-objdump", ".cxx-objdump", ]
+Creole = [".creole", ]
+Crystal = [".cr", ]
+Csound = [".csd", ]
+Cucumber = [".feature", ]
+Cuda = [".cu", ".cuh", ]
+Cycript = [".cy", ]
+Cython = [".pyx", ".pxd", ".pxi", ]
+D = [".di", ]
+D-ObjDump = [".d-objdump", ]
+"DIGITAL Command Language" = [".com", ]
+DM = [".dm", ]
+"DNS Zone" = [".zone", ".arpa", ]
+"Darcs Patch" = [".darcspatch", ".dpatch", ]
+Dart = [".dart", ]
+Diff = [".diff", ".patch", ]
+Dockerfile = [".dockerfile", "Dockerfile", ]
+Dogescript = [".djs", ]
+Dylan = [".dylan", ".dyl", ".intr", ".lid", ]
+E = [".E", ]
+ECL = [".ecl", ".eclxml", ]
+Eagle = [".sch", ".brd", ]
+"Ecere Projects" = [".epj", ]
+Eiffel = [".e", ]
+Elixir = [".ex", ".exs", ]
+Elm = [".elm", ]
+"Emacs Lisp" = [".el", ".emacs", ".emacs.desktop", ]
+EmberScript = [".em", ".emberscript", ]
+Erlang = [".erl", ".escript", ".hrl", ".xrl", ".yrl", ]
+"F#" = [".fs", ".fsi", ".fsx", ]
+FLUX = [".flux", ]
+FORTRAN = [".f90", ".f", ".f03", ".f08", ".f77", ".f95", ".for", ".fpp", ]
+Factor = [".factor", ]
+Fancy = [".fy", ".fancypack", ]
+Fantom = [".fan", ]
+Formatted = [".eam.fs", ]
+Forth = [".fth", ".4th", ".forth", ".frt", ]
+FreeMarker = [".ftl", ]
+G-code = [".g", ".gco", ".gcode", ]
+GAMS = [".gms", ]
+GAP = [".gap", ".gi", ]
+GAS = [".s", ]
+GDScript = [".gd", ]
+GLSL = [".glsl", ".fp", ".frag", ".frg", ".fsh", ".fshader", ".geo", ".geom", ".glslv", ".gshader", ".shader", ".vert", ".vrx", ".vsh", ".vshader", ]
+Genshi = [".kid", ]
+"Gentoo Ebuild" = [".ebuild", ]
+"Gentoo Eclass" = [".eclass", ]
+"Gettext Catalog" = [".po", ".pot", ]
+Glyph = [".glf", ]
+Gnuplot = [".gp", ".gnu", ".gnuplot", ".plot", ".plt", ]
+Go = [".go", ]
+Golo = [".golo", ]
+Gosu = [".gst", ".gsx", ".vark", ]
+Grace = [".grace", ]
+Gradle = [".gradle", ]
+"Grammatical Framework" = [".gf", ]
+GraphQL = [".graphql", ]
+"Graphviz (DOT)" = [".dot", ".gv", ]
+Groff = [".man", ".1", ".1in", ".1m", ".1x", ".2", ".3", ".3in", ".3m", ".3qt", ".3x", ".4", ".5", ".6", ".7", ".8", ".9", ".me", ".rno", ".roff", ]
+Groovy = [".groovy", ".grt", ".gtpl", ".gvy", ]
+"Groovy Server Pages" = [".gsp", ]
+HCL = [".hcl", ".tf", ]
+HLSL = [".hlsl", ".fxh", ".hlsli", ]
+HTML = [".html", ".htm", ".html.hl", ".xht", ".xhtml", ]
+"HTML+Django" = [".mustache", ".jinja", ]
+"HTML+EEX" = [".eex", ]
+"HTML+ERB" = [".erb", ".erb.deface", ]
+"HTML+PHP" = [".phtml", ]
+HTTP = [".http", ]
+Haml = [".haml", ".haml.deface", ]
+Handlebars = [".handlebars", ".hbs", ]
+Harbour = [".hb", ]
+Haskell = [".hs", ".hsc", ]
+Haxe = [".hx", ".hxsl", ]
+Hy = [".hy", ]
+IDL = [".dlm", ]
+"IGOR Pro" = [".ipf", ]
+INI = [".ini", ".cfg", ".prefs", ".properties", ]
+"IRC log" = [".irclog", ".weechatlog", ]
+Idris = [".idr", ".lidr", ]
+"Inform 7" = [".ni", ".i7x", ]
+"Inno Setup" = [".iss", ]
+Io = [".io", ]
+Ioke = [".ik", ]
+Isabelle = [".thy", ]
+J = [".ijs", ]
+JFlex = [".flex", ".jflex", ]
+JSON = [".json", ".geojson", ".lock", ".topojson", ]
+JSON5 = [".json5", ]
+JSONLD = [".jsonld", ]
+JSONiq = [".jq", ]
+JSX = [".jsx", ]
+Jade = [".jade", ]
+Jasmin = [".j", ]
+Java = [".java", ]
+"Java Server Pages" = [".jsp", ]
+JavaScript = [".js", "._js", ".bones", ".es6", ".jake", ".jsb", ".jscad", ".jsfl", ".jsm", ".jss", ".njs", ".pac", ".sjs", ".ssjs", ".xsjs", ".xsjslib", ]
+Julia = [".jl", ]
+"Jupyter Notebook" = [".ipynb", ]
+KRL = [".krl", ]
+KiCad = [".kicad_pcb", ]
+Kit = [".kit", ]
+Kotlin = [".kt", ".ktm", ".kts", ]
+LFE = [".lfe", ]
+LLVM = [".ll", ]
+LOLCODE = [".lol", ]
+LSL = [".lsl", ".lslp", ]
+LabVIEW = [".lvproj", ]
+Lasso = [".lasso", ".las", ".lasso8", ".lasso9", ".ldml", ]
+Latte = [".latte", ]
+Lean = [".lean", ".hlean", ]
+Less = [".less", ]
+Lex = [".lex", ]
+LilyPond = [".ly", ".ily", ]
+"Linker Script" = [".ld", ".lds", ]
+Liquid = [".liquid", ]
+"Literate Agda" = [".lagda", ]
+"Literate CoffeeScript" = [".litcoffee", ]
+"Literate Haskell" = [".lhs", ]
+LiveScript = [".ls", "._ls", ]
+Logos = [".xm", ".x", ".xi", ]
+Logtalk = [".lgt", ".logtalk", ]
+LookML = [".lookml", ]
+Lua = [".lua", ".nse", ".pd_lua", ".rbxs", ".wlua", ]
+M = [".mumps", ]
+M4 = [".m4", ]
+MAXScript = [".mcr", ]
+MTML = [".mtml", ]
+MUF = [".muf", ]
+Makefile = [".mak", ".mk", ".mkfile", "Makefile", ]
+Mako = [".mako", ".mao", ]
+Maple = [".mpl", ]
+Markdown = [".md", ".markdown", ".mkd", ".mkdn", ".mkdown", ".ron", ]
+Mask = [".mask", ]
+Mathematica = [".mathematica", ".cdf", ".ma", ".mt", ".nb", ".nbp", ".wl", ".wlt", ]
+Matlab = [".matlab", ]
+Max = [".maxpat", ".maxhelp", ".maxproj", ".mxt", ".pat", ]
+MediaWiki = [".mediawiki", ".wiki", ]
+Metal = [".metal", ]
+MiniD = [".minid", ]
+Mirah = [".druby", ".duby", ".mir", ".mirah", ]
+Modelica = [".mo", ]
+"Module Management System" = [".mms", ".mmk", ]
+Monkey = [".monkey", ]
+MoonScript = [".moon", ]
+Myghty = [".myt", ]
+NSIS = [".nsi", ".nsh", ]
+NetLinx = [".axs", ".axi", ]
+"NetLinx+ERB" = [".axs.erb", ".axi.erb", ]
+NetLogo = [".nlogo", ]
+Nginx = [".nginxconf", ]
+Nimrod = [".nim", ".nimrod", ]
+Ninja = [".ninja", ]
+Nit = [".nit", ]
+Nix = [".nix", ]
+Nu = [".nu", ]
+NumPy = [".numpy", ".numpyw", ".numsc", ]
+OCaml = [".ml", ".eliom", ".eliomi", ".ml4", ".mli", ".mll", ".mly", ]
+ObjDump = [".objdump", ]
+"Objective-C++" = [".mm", ]
+Objective-J = [".sj", ]
+Octave = [".oct", ]
+Omgrofl = [".omgrofl", ]
+Opa = [".opa", ]
+Opal = [".opal", ]
+OpenCL = [".cl", ".opencl", ]
+"OpenEdge ABL" = [".p", ]
+OpenSCAD = [".scad", ]
+Org = [".org", ]
+Ox = [".ox", ".oxh", ".oxo", ]
+Oxygene = [".oxygene", ]
+Oz = [".oz", ]
+PAWN = [".pwn", ]
+PHP = [".php", ".aw", ".ctp", ".php3", ".php4", ".php5", ".phps", ".phpt", ]
+"POV-Ray SDL" = [".pov", ]
+Pan = [".pan", ]
+Papyrus = [".psc", ]
+Parrot = [".parrot", ]
+"Parrot Assembly" = [".pasm", ]
+"Parrot Internal Representation" = [".pir", ]
+Pascal = [".pas", ".dfm", ".dpr", ".lpr", ]
+Perl = [".pl", ".al", ".perl", ".ph", ".plx", ".pm", ".psgi", ".t", ]
+Perl6 = [".6pl", ".6pm", ".nqp", ".p6", ".p6l", ".p6m", ".pl6", ".pm6", ]
+Pickle = [".pkl", ]
+PigLatin = [".pig", ]
+Pike = [".pike", ".pmod", ]
+Pod = [".pod", ]
+PogoScript = [".pogo", ]
+Pony = [".pony", ]
+PostScript = [".ps", ".eps", ]
+PowerShell = [".ps1", ".psd1", ".psm1", ]
+Processing = [".pde", ]
+Prolog = [".prolog", ".yap", ]
+"Propeller Spin" = [".spin", ]
+"Protocol Buffer" = [".proto", ]
+"Public Key" = [".pub", ]
+"Pure Data" = [".pd", ]
+PureBasic = [".pb", ".pbi", ]
+PureScript = [".purs", ]
+Python = [".py", ".bzl", ".gyp", ".lmi", ".pyde", ".pyp", ".pyt", ".pyw", ".tac", ".wsgi", ".xpy", ]
+"Python traceback" = [".pytb", ]
+QML = [".qml", ".qbs", ]
+QMake = [".pri", ]
+R = [".r", ".rd", ".rsx", ]
+RAML = [".raml", ]
+RDoc = [".rdoc", ]
+REALbasic = [".rbbas", ".rbfrm", ".rbmnu", ".rbres", ".rbtbar", ".rbuistate", ]
+RHTML = [".rhtml", ]
+RMarkdown = [".rmd", ]
+Racket = [".rkt", ".rktd", ".rktl", ".scrbl", ]
+"Ragel in Ruby Host" = [".rl", ]
+"Raw token data" = [".raw", ]
+Rebol = [".reb", ".r2", ".r3", ".rebol", ]
+Red = [".red", ".reds", ]
+Redcode = [".cw", ]
+"Ren'Py" = [".rpy", ]
+RenderScript = [".rsh", ]
+RobotFramework = [".robot", ]
+Rouge = [".rg", ]
+Ruby = [".rb", ".builder", ".gemspec", ".god", ".irbrc", ".jbuilder", ".mspec", ".podspec", ".rabl", ".rake", ".rbuild", ".rbw", ".rbx", ".ru", ".ruby", ".thor", ".watchr", ]
+Rust = [".rs", ".rs.in", ]
+SAS = [".sas", ]
+SCSS = [".scss", ]
+SMT = [".smt2", ".smt", ]
+SPARQL = [".sparql", ".rq", ]
+SQF = [".sqf", ".hqf", ]
+SQL = [".pls", ".pck", ".pkb", ".pks", ".plb", ".plsql", ".sql", ".cql", ".ddl", ".prc", ".tab", ".udf", ".viw", ".db2", ]
+STON = [".ston", ]
+SVG = [".svg", ]
+Sage = [".sage", ".sagews", ]
+SaltStack = [".sls", ]
+Sass = [".sass", ]
+Scala = [".scala", ".sbt", ]
+Scaml = [".scaml", ]
+Scheme = [".scm", ".sld", ".sps", ".ss", ]
+Scilab = [".sci", ".sce", ]
+Self = [".self", ]
+Shell = [".sh", ".bash", ".bats", ".command", ".ksh", ".sh.in", ".tmux", ".tool", ".zsh", ]
+ShellSession = [".sh-session", ]
+Shen = [".shen", ]
+Slash = [".sl", ]
+Slim = [".slim", ]
+Smali = [".smali", ]
+Smalltalk = [".st", ]
+Smarty = [".tpl", ]
+Solidity = [".sol", ]
+SourcePawn = [".sp", ".sma", ]
+Squirrel = [".nut", ]
+Stan = [".stan", ]
+"Standard ML" = [".ML", ".fun", ".sig", ".sml", ]
+Stata = [".do", ".ado", ".doh", ".ihlp", ".mata", ".matah", ".sthlp", ]
+Stylus = [".styl", ]
+SuperCollider = [".scd", ]
+Swift = [".swift", ]
+SystemVerilog = [".sv", ".svh", ".vh", ]
+TOML = [".toml", ]
+TXL = [".txl", ]
+Tcl = [".tcl", ".adp", ".tm", ]
+Tcsh = [".tcsh", ".csh", ]
+TeX = [".tex", ".aux", ".bbx", ".bib", ".cbx", ".dtx", ".ins", ".lbx", ".ltx", ".mkii", ".mkiv", ".mkvi", ".sty", ".toc", ]
+Tea = [".tea", ]
+Text = [".txt", ".no", ]
+Textile = [".textile", ]
+Thrift = [".thrift", ]
+Turing = [".tu", ]
+Turtle = [".ttl", ]
+Twig = [".twig", ]
+TypeScript = [".ts", ".tsx", ]
+"Unified Parallel C" = [".upc", ]
+"Unity3D Asset" = [".anim", ".asset", ".mat", ".meta", ".prefab", ".unity", ]
+Uno = [".uno", ]
+UnrealScript = [".uc", ]
+UrWeb = [".ur", ".urs", ]
+VCL = [".vcl", ]
+VHDL = [".vhdl", ".vhd", ".vhf", ".vhi", ".vho", ".vhs", ".vht", ".vhw", ]
+Vala = [".vala", ".vapi", ]
+Verilog = [".veo", ]
+VimL = [".vim", ]
+"Visual Basic" = [".vb", ".bas", ".frm", ".frx", ".vba", ".vbhtml", ".vbs", ]
+Volt = [".volt", ]
+Vue = [".vue", ]
+"Web Ontology Language" = [".owl", ]
+WebAssembly = [".wat", ]
+WebIDL = [".webidl", ]
+X10 = [".x10", ]
+XC = [".xc", ]
+XML = [".xml", ".ant", ".axml", ".ccxml", ".clixml", ".cproject", ".csl", ".csproj", ".ct", ".dita", ".ditamap", ".ditaval", ".dll.config", ".dotsettings", ".filters", ".fsproj", ".fxml", ".glade", ".grxml", ".iml", ".ivy", ".jelly", ".jsproj", ".kml", ".launch", ".mdpolicy", ".mxml", ".nproj", ".nuspec", ".odd", ".osm", ".plist", ".props", ".ps1xml", ".psc1", ".pt", ".rdf", ".rss", ".scxml", ".srdf", ".storyboard", ".stTheme", ".sublime-snippet", ".targets", ".tmCommand", ".tml", ".tmLanguage", ".tmPreferences", ".tmSnippet", ".tmTheme", ".ui", ".urdf", ".ux", ".vbproj", ".vcxproj", ".vssettings", ".vxml", ".wsdl", ".wsf", ".wxi", ".wxl", ".wxs", ".x3d", ".xacro", ".xaml", ".xib", ".xlf", ".xliff", ".xmi", ".xml.dist", ".xproj", ".xsd", ".xul", ".zcml", ]
+XPages = [".xsp-config", ".xsp.metadata", ]
+XProc = [".xpl", ".xproc", ]
+XQuery = [".xquery", ".xq", ".xql", ".xqm", ".xqy", ]
+XS = [".xs", ]
+XSLT = [".xslt", ".xsl", ]
+Xojo = [".xojo_code", ".xojo_menu", ".xojo_report", ".xojo_script", ".xojo_toolbar", ".xojo_window", ]
+Xtend = [".xtend", ]
+YAML = [".yml", ".reek", ".rviz", ".sublime-syntax", ".syntax", ".yaml", ".yaml-tmlanguage", ]
+YANG = [".yang", ]
+Yacc = [".y", ".yacc", ".yy", ]
+Zephir = [".zep", ]
+Zig = [".zig", ]
+Zimpl = [".zimpl", ".zmpl", ".zpl", ]
+desktop = [".desktop", ".desktop.in", ]
+eC = [".ec", ".eh", ]
+edn = [".edn", ]
+fish = [".fish", ]
+mupad = [".mu", ]
+nesC = [".nc", ]
+ooc = [".ooc", ]
+reStructuredText = [".rst", ".rest", ".rest.txt", ".rst.txt", ]
+wisp = [".wisp", ]
+xBase = [".prg", ".prw", ]
+

pr_agent/settings/pr_code_suggestions_prompts.toml

@@ -0,0 +1,79 @@
+[pr_code_suggestions_prompt]
+system="""You are a language model called CodiumAI-PR-Code-Reviewer.
+Your task is to provide meaningfull non-trivial code suggestions to improve the new code in a PR (the '+' lines).
+- Try to give important suggestions like fixing code problems, issues and bugs. As a second priority, provide suggestions for meaningfull code improvements, like performance, vulnerability, modularity, and best practices.
+- Suggestions should refer only to the 'new hunk' code, and focus on improving the new added code lines, with '+'.
+- Provide the exact line number range (inclusive) for each issue.
+- Assume there is additional code in the relevant file that is not included in the diff.
+- Provide up to {{ num_code_suggestions }} code suggestions.
+- Make sure not to provide suggestions repeating modifications already implemented in the new PR code (the '+' lines).
+- Don't output line numbers in the 'improved code' snippets.
+
+You must use the following JSON schema to format your answer:
+```json
+{
+    "Code suggestions": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": {{ num_code_suggestions }},
+      "uniqueItems": "true",
+      "items": {
+        "relevant file": {
+          "type": "string",
+          "description": "the relevant file full path"
+        },
+        "suggestion content": {
+          "type": "string",
+          "description": "a concrete suggestion for meaningfully improving the new PR code."
+        },
+        "existing code": {
+          "type": "string",
+          "description": "a code snippet showing authentic relevant code lines from a 'new hunk' section. It must be continuous, correctly formatted and indented, and without line numbers."
+        },
+        "relevant lines": {
+          "type": "string",
+          "description": "the relevant lines in the 'new hunk' sections, in the format of 'start_line-end_line'. For example: '10-15'. They should be derived from the hunk line numbers, and correspond to the 'existing code' snippet above."
+        },
+        "improved code": {
+          "type": "string",
+          "description": "a new code snippet that can be used to replace the relevant lines in 'new hunk' code. Replacement suggestions should be complete, correctly formatted and indented, and without line numbers."
+        }
+      }
+    }
+}
+```
+
+Example input:
+'
+## src/file1.py
+---new_hunk---
+```
+[new hunk code, annotated with line numbers]
+```
+---old_hunk---
+```
+[old hunk code]
+```
+...
+'
+
+Don't repeat the prompt in the answer, and avoid outputting the 'type' and 'description' fields.
+"""
+
+user="""PR Info:
+Title: '{{title}}'
+Branch: '{{branch}}'
+Description: '{{description}}'
+{%- if language %}
+Main language: {{language}}
+{%- endif %}
+
+
+The PR Diff:
+```
+{{diff}}
+```
+
+Response (should be a valid JSON, and nothing else):
+```json
+"""

pr_agent/settings/pr_description_prompts.toml

@@ -0,0 +1,45 @@
+[pr_description_prompt]
+system="""You are CodiumAI-PR-Reviewer, a language model designed to review git pull requests.
+Your task is to provide full description of the PR content.
+- Make sure not to focus the new PR code (the '+' lines).
+
+You must use the following JSON schema to format your answer:
+```json
+{
+  "PR Title": {
+      "type": "string",
+      "description": "an informative title for the PR, describing its main theme"
+  },
+  "PR Type": {
+      "type": "string",
+      "description": possible values are: ["Bug fix", "Tests", "Bug fix with tests", "Refactoring", "Enhancement", "Documentation", "Other"]
+    },
+  "PR Description": {
+      "type": "string",
+      "description": "an informative and concise description of the PR"
+  },
+  "PR Main Files Walkthrough": {
+      "type": "string",
+      "description": "a walkthrough of the PR changes. Review main files, in bullet points, and shortly describe the changes in each file (up to 10 most important files). Format: -`filename`: description of changes\n..."
+  }
+}
+
+Don't repeat the prompt in the answer, and avoid outputting the 'type' and 'description' fields.
+"""
+
+user="""PR Info:
+Branch: '{{branch}}'
+{%- if language %}
+Main language: {{language}}
+{%- endif %}
+
+
+The PR Git Diff:
+```
+{{diff}}
+```
+Note that lines in the diff body are prefixed with a symbol that represents the type of change: '-' for deletions, '+' for additions, and ' ' (a space) for unchanged lines.
+
+Response (should be a valid JSON, and nothing else):
+```json
+"""

pr_agent/settings/pr_information_from_user_prompts.toml

@@ -0,0 +1,34 @@
+[pr_information_from_user_prompt]
+system="""You are CodiumAI-PR-Reviewer, a language model designed to review git pull requests.
+Given the PR Info and the PR Git Diff, generate 3 short questions about the PR code for the PR author.
+The goal of the questions is to help the language model understand the PR better, so the questions should be insightful, informative, non-trivial, and relevant to the PR.
+You should prefer asking yes\\no questions, or multiple choice questions. Also add at least one open-ended question, but make sure they are not too difficult, and can be answered in a sentence or two.
+
+
+Example output:
+'
+Questions to better understand the PR:
+1) ...
+2) ...
+...
+'
+"""
+
+user="""PR Info:
+Title: '{{title}}'
+Branch: '{{branch}}'
+Description: '{{description}}'
+{%- if language %}
+Main language: {{language}}
+{%- endif %}
+
+
+The PR Git Diff:
+```
+{{diff}}
+```
+Note that lines in the diff body are prefixed with a symbol that represents the type of change: '-' for deletions, '+' for additions, and ' ' (a space) for unchanged lines
+
+
+Response:
+"""

pr_agent/settings/pr_questions_prompts.toml

@@ -1,9 +1,9 @@
 [pr_questions_prompt]
 system="""You are CodiumAI-PR-Reviewer, a language model designed to review git pull requests.
 Your task is to answer questions about the new PR code (the '+' lines), and provide feedback.
-Be informative, constructive, and give examples. Try to be as specific as possible, and don't avoid answering the questions.
+Be informative, constructive, and give examples. Try to be as specific as possible.
+Don't avoid answering the questions. You must answer the questions, as best as you can, without adding unrelated content.
 Make sure not to repeat modifications already implemented in the new PR code (the '+' lines).
-Answer only the questions, and don't add unrelated content.
 """
 
 user="""PR Info:

pr_agent/settings/pr_reviewer_prompts.toml

@@ -2,11 +2,11 @@
 system="""You are CodiumAI-PR-Reviewer, a language model designed to review git pull requests.
 Your task is to provide constructive and concise feedback for the PR, and also provide meaningfull code suggestions to improve the new PR code (the '+' lines).
 - Provide up to {{ num_code_suggestions }} code suggestions.
+{%- if num_code_suggestions > 0 %}
 - Try to focus on important suggestions like fixing code problems, issues and bugs. As a second priority, provide suggestions for meaningfull code improvements, like performance, vulnerability, modularity, and best practices.
-{%- if extended_code_suggestions %}
+- Suggestions should focus on improving the new added code lines.
-- For each suggestion, provide a short and concise code snippet to illustrate the existing code, and the improved code.
+- Make sure not to provide suggestions repeating modifications already implemented in the new PR code (the '+' lines).
 {%- endif %}
-- Make sure not to provide suggestion repeating modifications already implemented in the new PR code (the '+' lines).
 
 You must use the following JSON schema to format your answer:
 ```json
@@ -16,20 +16,28 @@ You must use the following JSON schema to format your answer:
       "type": "string",
       "description": "a short explanation of the PR"
     },
-    "Description and title": {
-      "type": "string",
-      "description": "yes\\no question: does this PR have a relevant description and title"
-    },
     "Type of PR": {
       "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",
       "description": "yes\\no question: does this PR have relevant tests ?"
     },
 {%- endif %}
+{%- if question_str %}
+    "Insights from user's answer": {
+      "type": "string",
+      "description": "shortly summarize the insights you gained from the user's answers to the questions"
+    },
+{%- endif %}
 {%- if require_focused %}
     "Focused PR": {
       "type": "string",
@@ -40,50 +48,29 @@ You must use the following JSON schema to format your answer:
   "PR Feedback": {
     "General PR suggestions": {
       "type": "string",
-      "description": "important suggestions for the contributors and maintainers of this PR, may include overall structure, primary purpose and best practices. consider using specific filenames, classes and functions names. explain yourself!"
+      "description": "General suggestions and feedback for the contributors and maintainers of this PR. May include important suggestions for the overall structure, primary purpose, best practices, critical bugs, and other aspects of the PR. Explain your suggestions."
     },
+{%- if num_code_suggestions > 0 %}
     "Code suggestions": {
       "type": "array",
       "maxItems": {{ num_code_suggestions }},
       "uniqueItems": true,
       "items": {
-        "suggestion number": {
-          "type": "int",
-          "description": "suggestion number, starting from 1"
-        },
         "relevant file": {
           "type": "string",
-          "description": "the relevant file name"
+          "description": "the relevant file full path"
         },
         "suggestion content": {
           "type": "string",
-{%- if extended_code_suggestions %}
-          "description": "a concrete suggestion for meaningfully improving the new PR code. Don't repeat previous suggestions. Add tags with importance measure that matches each suggestion ('important' or 'medium'). Do not make suggestions for updating or adding docstrings, renaming PR title and description, or linter like.
-{%- else %}
           "description": "a concrete suggestion for meaningfully improving the new PR code. Also describe how, specifically, the suggestion can be applied to new PR code. Add tags with importance measure that matches each suggestion ('important' or 'medium'). Do not make suggestions for updating or adding docstrings, renaming PR title and description, or linter like.
-{%- endif %}
         },
-{%- if extended_code_suggestions %}
+        "relevant line in file": {
-        "why": {
           "type": "string",
-          "description": "shortly explain why this suggestion is important"
+          "description": "an authentic single code line from the PR git diff section, to which the suggestion applies."
-        },
-        "code example": {
-          "type": "object",
-          "properties": {
-            "before code": {
-              "type": "string",
-              "description": "Short and concise code snippet, to illustrate the existing code"
-            },
-            "after code": {
-              "type": "string",
-              "description": "Short and concise code snippet, to illustrate the improved code"
-            }
-          }
         }
-{%- endif %}
       }
     },
+{%- endif %}
 {%- if require_security %}
     "Security concerns": {
       "type": "string",
@@ -101,8 +88,10 @@ Example output:
     "PR Analysis":
     {
         "Main theme": "xxx",
-        "Description and title": "Yes",
         "Type of PR": "Bug fix",
+{%- if require_score %}
+        "Score": 89,
+{%- endif %}
 {%- if require_tests %}
         "Relevant tests added": "No",
 {%- endif %}
@@ -113,24 +102,18 @@ Example output:
     "PR Feedback":
     {
         "General PR suggestions": "..., `xxx`...",
+{%- if num_code_suggestions > 0 %}
         "Code suggestions": [
             {
-                "suggestion number": 1,
+                "relevant file": "directory/xxx.py",
-                "relevant file": "xxx.py",
                 "suggestion content": "xxx [important]",
-{%- if extended_code_suggestions %}
+                "relevant line in file": "xxx",
-                "why": "xxx",
-                "code example":
-                {
-                    "before code": "xxx",
-                    "after code": "xxx"
-                }
-{%- endif %}
             },
             ...
         ]
-{%- if require_security %},
+{%- endif %}
-       "Security concerns": "No, because ..."
+{%- if require_security %}
+        "Security concerns": "No, because ..."
 {%- endif %}
     }
 }
@@ -147,6 +130,16 @@ Description: '{{description}}'
 Main language: {{language}}
 {%- endif %}
 
+{%- if question_str %}
+######
+Here are questions to better understand the PR. Use the answers to provide better feedback.
+
+{{question_str|trim}}
+
+User answers:
+{{answer_str|trim}}
+######
+{%- endif %}
 
 The PR Git Diff:
 ```

pr_agent/settings/pr_update_changelog.toml

@@ -0,0 +1,34 @@
+[pr_update_changelog_prompt]
+system="""You are a language model called CodiumAI-PR-Changlog-summarizer.
+Your task is to update the CHANGELOG.md file of the project, to shortly summarize important changes introduced in this PR (the '+' lines).
+- The output should match the existing CHANGELOG.md format, style and conventions, so it will look like a natural part of the file. For example, if previous changes were summarized in a single line, you should do the same.
+- Don't repeat previous changes. Generate only new content, that is not already in the CHANGELOG.md file.
+- Be general, and avoid specific details, files, etc. The output should be minimal, no more than 3-4 short lines. Ignore non-relevant subsections.
+"""
+
+user="""PR Info:
+Title: '{{title}}'
+Branch: '{{branch}}'
+Description: '{{description}}'
+{%- if language %}
+Main language: {{language}}
+{%- endif %}
+
+
+The PR Diff:
+```
+{{diff}}
+```
+
+Current date:
+```
+{{today}}
+```
+
+The current CHANGELOG.md:
+```
+{{ changelog_file_str }}
+```
+
+Response:
+"""

pr_agent/tools/pr_code_suggestions.py

@@ -0,0 +1,133 @@
+import copy
+import json
+import logging
+import textwrap
+
+from jinja2 import Environment, StrictUndefined
+
+from pr_agent.algo.ai_handler import AiHandler
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
+from pr_agent.algo.token_handler import TokenHandler
+from pr_agent.algo.utils import try_fix_json
+from pr_agent.config_loader import settings
+from pr_agent.git_providers import BitbucketProvider, get_git_provider
+from pr_agent.git_providers.git_provider import get_main_pr_language
+
+
+class PRCodeSuggestions:
+    def __init__(self, pr_url: str, cli_mode=False):
+
+        self.git_provider = get_git_provider()(pr_url)
+        self.main_language = get_main_pr_language(
+            self.git_provider.get_languages(), self.git_provider.get_files()
+        )
+        self.ai_handler = AiHandler()
+        self.patches_diff = None
+        self.prediction = None
+        self.cli_mode = cli_mode
+        self.vars = {
+            "title": self.git_provider.pr.title,
+            "branch": self.git_provider.get_pr_branch(),
+            "description": self.git_provider.get_pr_description(),
+            "language": self.main_language,
+            "diff": "",  # empty diff for initial calculation
+            'num_code_suggestions': settings.pr_code_suggestions.num_code_suggestions,
+        }
+        self.token_handler = TokenHandler(self.git_provider.pr,
+                                          self.vars,
+                                          settings.pr_code_suggestions_prompt.system,
+                                          settings.pr_code_suggestions_prompt.user)
+
+    async def suggest(self):
+        assert type(self.git_provider) != BitbucketProvider, "Bitbucket is not supported for now"
+
+        logging.info('Generating code suggestions for PR...')
+        if settings.config.publish_output:
+            self.git_provider.publish_comment("Preparing review...", is_temporary=True)
+        await retry_with_fallback_models(self._prepare_prediction)
+        logging.info('Preparing PR review...')
+        data = self._prepare_pr_code_suggestions()
+        if settings.config.publish_output:
+            logging.info('Pushing PR review...')
+            self.git_provider.remove_initial_comment()
+            logging.info('Pushing inline code comments...')
+            self.push_inline_code_suggestions(data)
+
+    async def _prepare_prediction(self, model: str):
+        logging.info('Getting PR diff...')
+        # we are using extended hunk with line numbers for code suggestions
+        self.patches_diff = get_pr_diff(self.git_provider,
+                                        self.token_handler,
+                                        model,
+                                        add_line_numbers_to_hunks=True,
+                                        disable_extra_lines=True)
+        logging.info('Getting AI prediction...')
+        self.prediction = await self._get_prediction(model)
+
+    async def _get_prediction(self, model: str):
+        variables = copy.deepcopy(self.vars)
+        variables["diff"] = self.patches_diff  # update diff
+        environment = Environment(undefined=StrictUndefined)
+        system_prompt = environment.from_string(settings.pr_code_suggestions_prompt.system).render(variables)
+        user_prompt = environment.from_string(settings.pr_code_suggestions_prompt.user).render(variables)
+        if settings.config.verbosity_level >= 2:
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
+        response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
+                                                                        system=system_prompt, user=user_prompt)
+
+        return response
+
+    def _prepare_pr_code_suggestions(self) -> str:
+        review = self.prediction.strip()
+        try:
+            data = json.loads(review)
+        except json.decoder.JSONDecodeError:
+            if settings.config.verbosity_level >= 2:
+                logging.info(f"Could not parse json response: {review}")
+            data = try_fix_json(review, code_suggestions=True)
+        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}")
+            relevant_file = d['relevant file'].strip()
+            relevant_lines_str = d['relevant lines'].strip()
+            relevant_lines_start = int(relevant_lines_str.split('-')[0])  # absolute position
+            relevant_lines_end = int(relevant_lines_str.split('-')[-1])
+            content = d['suggestion content']
+            new_code_snippet = d['improved code']
+
+            if new_code_snippet:
+                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```"
+            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

@@ -0,0 +1,172 @@
+import copy
+import json
+import logging
+from typing import Tuple, List
+
+from jinja2 import Environment, StrictUndefined
+
+from pr_agent.algo.ai_handler import AiHandler
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
+from pr_agent.algo.token_handler import TokenHandler
+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
+
+
+class PRDescription:
+    def __init__(self, pr_url: str):
+        """
+        Initialize the PRDescription object with the necessary attributes and objects for generating a PR description using an AI model.
+        Args:
+            pr_url (str): The URL of the pull request.
+        """
+        
+        # Initialize the git provider and main PR language
+        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()
+        )
+    
+        # Initialize the AI handler
+        self.ai_handler = AiHandler()
+    
+        # Initialize the variables dictionary
+        self.vars = {
+            "title": self.git_provider.pr.title,
+            "branch": self.git_provider.get_pr_branch(),
+            "description": self.git_provider.get_pr_description(),
+            "language": self.main_pr_language,
+            "diff": "",  # empty diff for initial calculation
+        }
+    
+        # Initialize the token handler
+        self.token_handler = TokenHandler(
+            self.git_provider.pr,
+            self.vars,
+            settings.pr_description_prompt.system,
+            settings.pr_description_prompt.user,
+        )
+    
+        # Initialize patches_diff and prediction attributes
+        self.patches_diff = None
+        self.prediction = None
+
+    async def describe(self):
+        """
+        Generates a PR description using an AI model and publishes it to the PR.
+        """
+        logging.info('Generating a PR description...')
+        if settings.config.publish_output:
+            self.git_provider.publish_comment("Preparing pr description...", is_temporary=True)
+        
+        await retry_with_fallback_models(self._prepare_prediction)
+        
+        logging.info('Preparing 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)
+                if self.git_provider.is_supported("get_labels"):
+                    current_labels = self.git_provider.get_labels()
+                    if current_labels is None:
+                        current_labels = []
+                    self.git_provider.publish_labels(pr_types + current_labels)
+            self.git_provider.remove_initial_comment()
+        
+        return ""
+
+    async def _prepare_prediction(self, model: str) -> None:
+        """
+        Prepare the AI prediction for the PR description based on the provided model.
+
+        Args:
+            model (str): The name of the model to be used for generating the prediction.
+
+        Returns:
+            None
+
+        Raises:
+            Any exceptions raised by the 'get_pr_diff' and '_get_prediction' functions.
+
+        """
+        logging.info('Getting PR diff...')
+        self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
+        logging.info('Getting AI prediction...')
+        self.prediction = await self._get_prediction(model)
+
+    async def _get_prediction(self, model: str) -> str:
+        """
+        Generate an AI prediction for the PR description based on the provided model.
+
+        Args:
+            model (str): The name of the model to be used for generating the prediction.
+
+        Returns:
+            str: The generated AI prediction.
+        """
+        variables = copy.deepcopy(self.vars)
+        variables["diff"] = self.patches_diff  # update diff
+
+        environment = Environment(undefined=StrictUndefined)
+        system_prompt = environment.from_string(settings.pr_description_prompt.system).render(variables)
+        user_prompt = environment.from_string(settings.pr_description_prompt.user).render(variables)
+
+        if settings.config.verbosity_level >= 2:
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
+
+        response, finish_reason = await self.ai_handler.chat_completion(
+            model=model,
+            temperature=0.2,
+            system=system_prompt,
+            user=user_prompt
+        )
+
+        return response
+
+    def _prepare_pr_answer(self) -> Tuple[str, str, List[str], str]:
+        """
+        Prepare the PR description based on the AI prediction data.
+
+        Returns:
+        - title: a string containing the PR title.
+        - pr_body: a string containing the PR body in a markdown format.
+        - pr_types: a list of strings containing the PR types.
+        - markdown_text: a string containing the AI prediction data in a markdown format.
+        """
+        # Load the AI prediction data into a dictionary
+        data = json.loads(self.prediction)
+
+        # Initialization
+        markdown_text = pr_body = ""
+        pr_types = []
+
+        # Iterate over the dictionary items and append the key and value to 'markdown_text' in a markdown format
+        for key, value in data.items():
+            markdown_text += f"## {key}\n\n"
+            markdown_text += f"{value}\n\n"
+
+        # If the 'PR Type' key is present in the dictionary, split its value by comma and assign it to 'pr_types'
+        if 'PR Type' in data:
+            pr_types = data['PR Type'].split(',')
+
+        # Assign the value of the 'PR Title' key to 'title' variable and remove it from the dictionary
+        title = data.pop('PR Title')
+
+        # Iterate over the remaining dictionary items and append the key and value to 'pr_body' in a markdown format,
+        # except for the items containing the word 'walkthrough'
+        for key, value in data.items():
+            pr_body += f"{key}:\n"
+            if 'walkthrough' in key.lower():
+                pr_body += f"{value}\n"
+            else:
+                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, pr_types, markdown_text

pr_agent/tools/pr_information_from_user.py

@@ -0,0 +1,75 @@
+import copy
+import logging
+
+from jinja2 import Environment, StrictUndefined
+
+from pr_agent.algo.ai_handler import AiHandler
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
+from pr_agent.algo.token_handler import TokenHandler
+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
+
+
+
+
+class PRInformationFromUser:
+    def __init__(self, pr_url: str):
+        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()
+        )
+        self.ai_handler = AiHandler()
+        self.vars = {
+            "title": self.git_provider.pr.title,
+            "branch": self.git_provider.get_pr_branch(),
+            "description": self.git_provider.get_pr_description(),
+            "language": self.main_pr_language,
+            "diff": "",  # empty diff for initial calculation
+        }
+        self.token_handler = TokenHandler(self.git_provider.pr,
+                                          self.vars,
+                                          settings.pr_information_from_user_prompt.system,
+                                          settings.pr_information_from_user_prompt.user)
+        self.patches_diff = None
+        self.prediction = None
+
+    async def generate_questions(self):
+        logging.info('Generating question to the user...')
+        if settings.config.publish_output:
+            self.git_provider.publish_comment("Preparing questions...", is_temporary=True)
+        await retry_with_fallback_models(self._prepare_prediction)
+        logging.info('Preparing questions...')
+        pr_comment = self._prepare_pr_answer()
+        if settings.config.publish_output:
+            logging.info('Pushing questions...')
+            self.git_provider.publish_comment(pr_comment)
+            self.git_provider.remove_initial_comment()
+        return ""
+
+    async def _prepare_prediction(self, model):
+        logging.info('Getting PR diff...')
+        self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
+        logging.info('Getting AI prediction...')
+        self.prediction = await self._get_prediction(model)
+
+    async def _get_prediction(self, model: str):
+        variables = copy.deepcopy(self.vars)
+        variables["diff"] = self.patches_diff  # update diff
+        environment = Environment(undefined=StrictUndefined)
+        system_prompt = environment.from_string(settings.pr_information_from_user_prompt.system).render(variables)
+        user_prompt = environment.from_string(settings.pr_information_from_user_prompt.user).render(variables)
+        if settings.config.verbosity_level >= 2:
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
+        response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
+                                                                        system=system_prompt, user=user_prompt)
+        return response
+
+    def _prepare_pr_answer(self) -> str:
+        model_output = self.prediction.strip()
+        if settings.config.verbosity_level >= 2:
+            logging.info(f"answer_str:\n{model_output}")
+        answer_str = f"{model_output}\n\n Please respond to the questions above in the following format:\n\n" +\
+                     "\n>/answer\n>1) ...\n>2) ...\n>...\n"
+        return answer_str

pr_agent/tools/pr_questions.py

@@ -4,7 +4,7 @@ import logging
 from jinja2 import Environment, StrictUndefined
 
 from pr_agent.algo.ai_handler import AiHandler
-from pr_agent.algo.pr_processing import get_pr_diff
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
 from pr_agent.algo.token_handler import TokenHandler
 from pr_agent.config_loader import settings
 from pr_agent.git_providers import get_git_provider
@@ -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()
@@ -22,7 +23,7 @@ class PRQuestions:
         self.vars = {
             "title": self.git_provider.pr.title,
             "branch": self.git_provider.get_pr_branch(),
-            "description": self.git_provider.get_description(),
+            "description": self.git_provider.get_pr_description(),
             "language": self.main_pr_language,
             "diff": "",  # empty diff for initial calculation
             "questions": self.question_str,
@@ -34,23 +35,33 @@ 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_review:
+        if settings.config.publish_output:
             self.git_provider.publish_comment("Preparing answer...", is_temporary=True)
-        logging.info('Getting PR diff...')
+        await retry_with_fallback_models(self._prepare_prediction)
-        self.patches_diff = get_pr_diff(self.git_provider, self.token_handler)
-        logging.info('Getting AI prediction...')
-        self.prediction = await self._get_prediction()
         logging.info('Preparing answer...')
         pr_comment = self._prepare_pr_answer()
-        if settings.config.publish_review:
+        if settings.config.publish_output:
             logging.info('Pushing answer...')
             self.git_provider.publish_comment(pr_comment)
             self.git_provider.remove_initial_comment()
         return ""
 
-    async def _get_prediction(self):
+    async def _prepare_prediction(self, model: str):
+        logging.info('Getting PR diff...')
+        self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
+        logging.info('Getting AI prediction...')
+        self.prediction = await self._get_prediction(model)
+
+    async def _get_prediction(self, model: str):
         variables = copy.deepcopy(self.vars)
         variables["diff"] = self.patches_diff  # update diff
         environment = Environment(undefined=StrictUndefined)
@@ -59,7 +70,6 @@ class PRQuestions:
         if settings.config.verbosity_level >= 2:
             logging.info(f"\nSystem prompt:\n{system_prompt}")
             logging.info(f"\nUser prompt:\n{user_prompt}")
-        model = settings.config.model
         response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
                                                                         system=system_prompt, user=user_prompt)
         return response

pr_agent/tools/pr_reviewer.py

@@ -1,111 +1,262 @@
 import copy
 import json
 import logging
+from collections import OrderedDict
+from typing import Tuple, List
 
 from jinja2 import Environment, StrictUndefined
 
 from pr_agent.algo.ai_handler import AiHandler
-from pr_agent.algo.pr_processing import get_pr_diff
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
 from pr_agent.algo.token_handler import TokenHandler
-from pr_agent.algo.utils import convert_to_markdown
+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):
+    """
+    The PRReviewer class is responsible for reviewing a pull request and generating feedback using an AI model.
+    """
+    def __init__(self, pr_url: str, cli_mode: bool = False, is_answer: bool = False, args: list = None):
+        """
+        Initialize the PRReviewer object with the necessary attributes and objects to review a pull request.
 
-        self.git_provider = get_git_provider()(pr_url)
+        Args:
+            pr_url (str): The URL of the pull request to be reviewed.
+            cli_mode (bool, optional): Indicates whether the review is being done in command-line interface mode. Defaults to False.
+            is_answer (bool, optional): Indicates whether the review is being done in answer mode. Defaults to False.
+            args (list, optional): List of arguments passed to the PRReviewer class. Defaults to None.
+        """
+        self.parse_args(args)
+
+        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")
         self.ai_handler = AiHandler()
         self.patches_diff = None
         self.prediction = None
         self.cli_mode = cli_mode
+
+        answer_str, question_str = self._get_user_answers()
         self.vars = {
             "title": self.git_provider.pr.title,
             "branch": self.git_provider.get_pr_branch(),
             "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,
-            'extended_code_suggestions': settings.pr_reviewer.extended_code_suggestions,
             'num_code_suggestions': settings.pr_reviewer.num_code_suggestions,
+            'question_str': question_str,
+            'answer_str': answer_str,
         }
-        self.token_handler = TokenHandler(self.git_provider.pr,
-                                          self.vars,
-                                          settings.pr_review_prompt.system,
-                                          settings.pr_review_prompt.user)
 
-    async def review(self):
+        self.token_handler = TokenHandler(
+            self.git_provider.pr,
+            self.vars,
+            settings.pr_review_prompt.system,
+            settings.pr_review_prompt.user
+        )
+
+    def parse_args(self, args: List[str]) -> None:
+        """
+        Parse the arguments passed to the PRReviewer class and set the 'incremental' attribute accordingly.
+
+        Args:
+            args: A list of arguments passed to the PRReviewer class.
+
+        Returns:
+            None
+        """
+        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) -> None:
+        """
+        Review the pull request and generate feedback.
+        """
         logging.info('Reviewing PR...')
-        if settings.config.publish_review:
+    
+        if settings.config.publish_output:
             self.git_provider.publish_comment("Preparing review...", is_temporary=True)
-        logging.info('Getting PR diff...')
+    
-        self.patches_diff = get_pr_diff(self.git_provider, self.token_handler)
+        await retry_with_fallback_models(self._prepare_prediction)
-        logging.info('Getting AI prediction...')
+    
-        self.prediction = await self._get_prediction()
         logging.info('Preparing PR review...')
         pr_comment = self._prepare_pr_review()
-        if settings.config.publish_review:
+    
+        if settings.config.publish_output:
             logging.info('Pushing PR review...')
             self.git_provider.publish_comment(pr_comment)
             self.git_provider.remove_initial_comment()
-        return ""
+        
+            if settings.pr_reviewer.inline_code_comments:
+                logging.info('Pushing inline code comments...')
+                self._publish_inline_code_comments()
 
-    async def _get_prediction(self):
+    async def _prepare_prediction(self, model: str) -> None:
+        """
+        Prepare the AI prediction for the pull request review.
+
+        Args:
+            model: A string representing the AI model to be used for the prediction.
+
+        Returns:
+            None
+        """
+        logging.info('Getting PR diff...')
+        self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
+        logging.info('Getting AI prediction...')
+        self.prediction = await self._get_prediction(model)
+
+    async def _get_prediction(self, model: str) -> str:
+        """
+        Generate an AI prediction for the pull request review.
+
+        Args:
+            model: A string representing the AI model to be used for the prediction.
+
+        Returns:
+            A string representing the AI prediction for the pull request review.
+        """
         variables = copy.deepcopy(self.vars)
         variables["diff"] = self.patches_diff  # update diff
+
         environment = Environment(undefined=StrictUndefined)
         system_prompt = environment.from_string(settings.pr_review_prompt.system).render(variables)
         user_prompt = environment.from_string(settings.pr_review_prompt.user).render(variables)
+
         if settings.config.verbosity_level >= 2:
             logging.info(f"\nSystem prompt:\n{system_prompt}")
             logging.info(f"\nUser prompt:\n{user_prompt}")
-        model = settings.config.model
+
-        response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
+        response, finish_reason = await self.ai_handler.chat_completion(
-                                                                        system=system_prompt, user=user_prompt)
+            model=model,
-        try:
+            temperature=0.2,
-            json.loads(response)
+            system=system_prompt,
-        except json.decoder.JSONDecodeError:
+            user=user_prompt
-            logging.warning("Could not decode JSON")
+        )
-            response = {}
+
         return response
 
     def _prepare_pr_review(self) -> str:
+        """
+        Prepare the PR review by processing the AI prediction and generating a markdown-formatted text that summarizes the feedback.
+        """
         review = self.prediction.strip()
+    
         try:
             data = json.loads(review)
         except json.decoder.JSONDecodeError:
-            logging.error("Unable to decode JSON response from AI")
+            data = try_fix_json(review)
-            data = {}
 
-        # reordering for nicer display
+        # Move 'Security concerns' key to 'PR Analysis' section for better display
-        if 'PR Feedback' in data:
+        if 'PR Feedback' in data and 'Security concerns' in data['PR Feedback']:
-            if 'Security concerns' in data['PR Feedback']:
+            val = data['PR Feedback']['Security concerns']
-                val = data['PR Feedback']['Security concerns']
+            del data['PR Feedback']['Security concerns']
-                del data['PR Feedback']['Security concerns']
+            data['PR Analysis']['Security concerns'] = val
-                data['PR Analysis']['Security concerns'] = val
+
+        # Filter out code suggestions that can be submitted as inline comments
+        if settings.config.git_provider != 'bitbucket' and settings.pr_reviewer.inline_code_comments and 'Code suggestions' in data['PR Feedback']:
+            data['PR Feedback']['Code suggestions'] = [
+                d for d in data['PR Feedback']['Code suggestions']
+                if any(key not in d for key in ('relevant file', 'relevant line in file', 'suggestion content'))
+            ]
+            if not data['PR Feedback']['Code suggestions']:
+                del data['PR Feedback']['Code suggestions']
+
+        # Add incremental review section
+        if self.incremental.is_incremental:
+            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()
 
+        # Add help text if not in CLI mode
         if not self.cli_mode:
             markdown_text += "\n### How to use\n"
             if user and '[bot]' not in user:
-                markdown_text += f"> Tag me in a comment '@{user}' to ask for a new review after you update the PR.\n"
+                markdown_text += bot_help_text(user)
-                markdown_text += "> You can also tag me and ask any question, " \
-                                 f"for example '@{user} is the PR ready for merge?'"
             else:
-                markdown_text += "> Add a comment that says 'review' to ask for a new review " \
+                markdown_text += actions_help_text
-                                 "after you update the PR.\n"
-                markdown_text += "> You can also add a comment that says 'answer QUESTION', " \
-                                 "for example 'answer is the PR ready for merge?'"
 
+        # Log markdown response if verbosity level is high
         if settings.config.verbosity_level >= 2:
             logging.info(f"Markdown response:\n{markdown_text}")
+    
         return markdown_text
+
+    def _publish_inline_code_comments(self) -> None:
+        """
+        Publishes inline comments on a pull request with code suggestions generated by the AI model.
+        """
+        if settings.pr_reviewer.num_code_suggestions == 0:
+            return
+
+        review = self.prediction.strip()
+        try:
+            data = json.loads(review)
+        except json.decoder.JSONDecodeError:
+            data = try_fix_json(review)
+
+        comments: List[str] = []
+        for suggestion in data.get('PR Feedback', {}).get('Code suggestions', []):
+            relevant_file = suggestion.get('relevant file', '').strip()
+            relevant_line_in_file = suggestion.get('relevant line in file', '').strip()
+            content = suggestion.get('suggestion content', '')
+            if not relevant_file or not relevant_line_in_file or not content:
+                logging.info("Skipping inline comment with missing file/line/content")
+                continue
+
+            if self.git_provider.is_supported("create_inline_comment"):
+                comment = self.git_provider.create_inline_comment(content, relevant_file, relevant_line_in_file)
+                if comment:
+                    comments.append(comment)
+            else:
+                self.git_provider.publish_inline_comment(content, relevant_file, relevant_line_in_file)
+
+        if comments:
+            self.git_provider.publish_inline_comments(comments)
+
+    def _get_user_answers(self) -> Tuple[str, str]:
+        """
+        Retrieves the question and answer strings from the discussion messages related to a pull request.
+
+        Returns:
+            A tuple containing the question and answer strings.
+        """
+        question_str = ""
+        answer_str = ""
+
+        if self.is_answer:
+            discussion_messages = self.git_provider.get_issue_comments()
+
+            for message in reversed(discussion_messages):
+                if "Questions to better understand the PR:" in message.body:
+                    question_str = message.body
+                elif '/answer' in message.body:
+                    answer_str = message.body
+
+                if answer_str and question_str:
+                    break
+
+        return question_str, answer_str

pr_agent/tools/pr_update_changelog.py

@@ -0,0 +1,171 @@
+import copy
+import logging
+from datetime import date
+from time import sleep
+from typing import Tuple
+
+from jinja2 import Environment, StrictUndefined
+
+from pr_agent.algo.ai_handler import AiHandler
+from pr_agent.algo.pr_processing import get_pr_diff, retry_with_fallback_models
+from pr_agent.algo.token_handler import TokenHandler
+from pr_agent.config_loader import settings
+from pr_agent.git_providers import get_git_provider, GithubProvider
+from pr_agent.git_providers.git_provider import get_main_pr_language
+
+CHANGELOG_LINES = 50
+
+
+class PRUpdateChangelog:
+    def __init__(self, pr_url: str, cli_mode=False, args=None):
+
+        self.git_provider = get_git_provider()(pr_url)
+        self.main_language = get_main_pr_language(
+            self.git_provider.get_languages(), self.git_provider.get_files()
+        )
+        self.commit_changelog = self._parse_args(args, settings)
+        self._get_changlog_file()  # self.changelog_file_str
+        self.ai_handler = AiHandler()
+        self.patches_diff = None
+        self.prediction = None
+        self.cli_mode = cli_mode
+        self.vars = {
+            "title": self.git_provider.pr.title,
+            "branch": self.git_provider.get_pr_branch(),
+            "description": self.git_provider.get_pr_description(),
+            "language": self.main_language,
+            "diff": "",  # empty diff for initial calculation
+            "changelog_file_str": self.changelog_file_str,
+            "today": date.today(),
+        }
+        self.token_handler = TokenHandler(self.git_provider.pr,
+                                          self.vars,
+                                          settings.pr_update_changelog_prompt.system,
+                                          settings.pr_update_changelog_prompt.user)
+
+    async def update_changelog(self):
+        assert type(self.git_provider) == GithubProvider, "Currently only Github is supported"
+
+        logging.info('Updating the changelog...')
+        if settings.config.publish_output:
+            self.git_provider.publish_comment("Preparing changelog updates...", is_temporary=True)
+        await retry_with_fallback_models(self._prepare_prediction)
+        logging.info('Preparing PR changelog updates...')
+        new_file_content, answer = self._prepare_changelog_update()
+        if settings.config.publish_output:
+            self.git_provider.remove_initial_comment()
+            logging.info('Publishing changelog updates...')
+            if self.commit_changelog:
+                logging.info('Pushing PR changelog updates to repo...')
+                self._push_changelog_update(new_file_content, answer)
+            else:
+                logging.info('Publishing PR changelog as comment...')
+                self.git_provider.publish_comment(f"**Changelog updates:**\n\n{answer}")
+
+    async def _prepare_prediction(self, model: str):
+        logging.info('Getting PR diff...')
+        self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
+        logging.info('Getting AI prediction...')
+        self.prediction = await self._get_prediction(model)
+
+    async def _get_prediction(self, model: str):
+        variables = copy.deepcopy(self.vars)
+        variables["diff"] = self.patches_diff  # update diff
+        environment = Environment(undefined=StrictUndefined)
+        system_prompt = environment.from_string(settings.pr_update_changelog_prompt.system).render(variables)
+        user_prompt = environment.from_string(settings.pr_update_changelog_prompt.user).render(variables)
+        if settings.config.verbosity_level >= 2:
+            logging.info(f"\nSystem prompt:\n{system_prompt}")
+            logging.info(f"\nUser prompt:\n{user_prompt}")
+        response, finish_reason = await self.ai_handler.chat_completion(model=model, temperature=0.2,
+                                                                        system=system_prompt, user=user_prompt)
+
+        return response
+
+    def _prepare_changelog_update(self) -> Tuple[str, str]:
+        answer = self.prediction.strip().strip("```").strip()
+        if hasattr(self, "changelog_file"):
+            existing_content = self.changelog_file.decoded_content.decode()
+        else:
+            existing_content = ""
+        if existing_content:
+            new_file_content = answer + "\n\n" + self.changelog_file.decoded_content.decode()
+        else:
+            new_file_content = answer
+
+        if not self.commit_changelog:
+            answer += "\n\n\n>to commit the new content to the CHANGELOG.md file, please type:" \
+                      "\n>'/update_changelog -commit'\n"
+
+        if settings.config.verbosity_level >= 2:
+            logging.info(f"answer:\n{answer}")
+
+        return new_file_content, answer
+
+    def _push_changelog_update(self, new_file_content, answer):
+        self.git_provider.repo_obj.update_file(path=self.changelog_file.path,
+                                               message="Update CHANGELOG.md",
+                                               content=new_file_content,
+                                               sha=self.changelog_file.sha,
+                                               branch=self.git_provider.get_pr_branch())
+        d = dict(body="CHANGELOG.md update",
+                 path=self.changelog_file.path,
+                 line=max(2, len(answer.splitlines())),
+                 start_line=1)
+
+        sleep(5)  # wait for the file to be updated
+        last_commit_id = list(self.git_provider.pr.get_commits())[-1]
+        try:
+            self.git_provider.pr.create_review(commit=last_commit_id, comments=[d])
+        except:
+            # we can't create a review for some reason, let's just publish a comment
+            self.git_provider.publish_comment(f"**Changelog updates:**\n\n{answer}")
+
+
+    def _get_default_changelog(self):
+        example_changelog = \
+"""
+Example:
+## <current_date>
+
+### Added
+...
+### Changed
+...
+### Fixed
+...
+"""
+        return example_changelog
+
+    def _parse_args(self, args, setting):
+        commit_changelog = False
+        if args and len(args) >= 1:
+            try:
+                if args[0] == "-commit":
+                    commit_changelog = True
+            except:
+                pass
+        else:
+            commit_changelog = setting.pr_update_changelog.push_changelog_changes
+
+        return commit_changelog
+
+    def _get_changlog_file(self):
+        try:
+            self.changelog_file = self.git_provider.repo_obj.get_contents("CHANGELOG.md",
+                                                                          ref=self.git_provider.get_pr_branch())
+            changelog_file_lines = self.changelog_file.decoded_content.decode().splitlines()
+            changelog_file_lines = changelog_file_lines[:CHANGELOG_LINES]
+            self.changelog_file_str = "\n".join(changelog_file_lines)
+        except:
+            self.changelog_file_str = ""
+            if self.commit_changelog:
+                logging.info("No CHANGELOG.md file found in the repository. Creating one...")
+                changelog_file = self.git_provider.repo_obj.create_file(path="CHANGELOG.md",
+                                                                             message='add CHANGELOG.md',
+                                                                             content="",
+                                                                             branch=self.git_provider.get_pr_branch())
+                self.changelog_file = changelog_file['content']
+
+        if not self.changelog_file_str:
+            self.changelog_file_str = self._get_default_changelog()

pyproject.toml

@@ -1,3 +1,63 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pr_agent"
+version = "0.0.1"
+
+authors = [
+  {name = "Itamar Friedman", email = "itamar.f@codium.ai"},
+]
+maintainers = [
+  {name = "Ori Kotek", email = "ori.k@codium.ai"},
+  {name = "Tal Ridnik", email = "tal.r@codium.ai"},
+  {name = "Hussam Lawen", email = "hussam.l@codium.ai"},
+  {name = "Sagi Medina", email = "sagi.m@codium.ai"}
+]
+description = "CodiumAI PR-Agent is an open-source tool to automatically analyze a pull request and provide several types of feedback"
+readme = "README.md"
+requires-python = ">=3.9"
+keywords = ["ai", "tool", "developer", "review", "agent"]
+license = {file = "LICENSE", name = "Apache 2.0 License"}
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: Independent",
+  "Programming Language :: Python :: 3",
+]
+
+dependencies = [
+  "dynaconf==3.1.12",
+  "fastapi==0.99.0",
+  "PyGithub==1.59.*",
+  "retry==0.9.2",
+  "openai==0.27.8",
+  "Jinja2==3.1.2",
+  "tiktoken==0.4.0",
+  "uvicorn==0.22.0",
+  "python-gitlab==3.15.0",
+  "pytest~=7.4.0",
+  "aiohttp~=3.8.4",
+  "atlassian-python-api==3.39.0",
+  "GitPython~=3.1.32",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/Codium-ai/pr-agent"
+
+[tool.setuptools]
+include-package-data = false
+license-files = ["LICENSE"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pr_agent"]
+
+[project.scripts]
+pr-agent = "pr_agent.cli:run"
+
+
 [tool.ruff]
 
 line-length = 120

requirements.txt

@@ -1,11 +1 @@
-dynaconf==3.1.12
+-e .
-fastapi==0.99.0
-PyGithub==1.58.2
-retry==0.9.2
-openai==0.27.8
-Jinja2==3.1.2
-tiktoken==0.4.0
-uvicorn==0.22.0
-python-gitlab==3.15.0
-pytest~=7.4.0
-aiohttp~=3.8.4

setup.py

@@ -0,0 +1,5 @@
+# for compatibility with legacy tools
+# see: https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html
+from setuptools import setup
+
+setup()

tests/unit/test_convert_to_markdown.py

@@ -46,7 +46,6 @@ class TestConvertToMarkdown:
     def test_simple_dictionary_input(self):
         input_data = {
             'Main theme': 'Test',
-            'Description and title': 'Test description',
             'Type of PR': 'Test type',
             'Relevant tests added': 'no',
             'Unrelated changes': 'n/a',  # won't be included in the output
@@ -54,14 +53,12 @@ class TestConvertToMarkdown:
             'General PR suggestions': 'general suggestion...',
             'Code suggestions': [
                 {
-                    'Suggestion number': 1,
                     'Code example': {
                         'Before': 'Code before',
                         'After': 'Code after'
                     }
                 },
                 {
-                    'Suggestion number': 2,
                     'Code example': {
                         'Before': 'Code before 2',
                         'After': 'Code after 2'
@@ -71,7 +68,6 @@ class TestConvertToMarkdown:
         }
         expected_output = """\
 - 🎯 **Main theme:** Test
-- 🔍 **Description and title:** Test description
 - 📌 **Type of PR:** Test type
 - 🧪 **Relevant tests added:** no
 - ✨ **Focused PR:** Yes
@@ -110,7 +106,6 @@ class TestConvertToMarkdown:
     def test_dictionary_input_containing_only_empty_dictionaries(self):
         input_data = {
             'Main theme': {},
-            'Description and title': {},
             'Type of PR': {},
             'Relevant tests added': {},
             'Unrelated changes': {},

tests/unit/test_fix_output.py

@@ -0,0 +1,82 @@
+# Generated by CodiumAI
+
+from pr_agent.algo.utils import try_fix_json
+
+
+class TestTryFixJson:
+    # Tests that JSON with complete 'Code suggestions' section returns expected output
+    def test_incomplete_code_suggestions(self):
+        review = '{"PR Analysis": {"Main theme": "xxx", "Type of PR": "Bug fix"}, "PR Feedback": {"General PR suggestions": "..., `xxx`...", "Code suggestions": [{"relevant file": "xxx.py", "suggestion content": "xxx [important]"}, {"suggestion number": 2, "relevant file": "yyy.py", "suggestion content": "yyy [incomp...'  # noqa: E501
+        expected_output = {
+            'PR Analysis': {
+                'Main theme': 'xxx',
+                'Type of PR': 'Bug fix'
+            },
+            'PR Feedback': {
+                'General PR suggestions': '..., `xxx`...',
+                'Code suggestions': [
+                    {
+                        'relevant file': 'xxx.py',
+                        'suggestion content': 'xxx [important]'
+                    }
+                ]
+            }
+        }
+        assert try_fix_json(review) == expected_output
+
+    def test_incomplete_code_suggestions_new_line(self):
+        review = '{"PR Analysis": {"Main theme": "xxx", "Type of PR": "Bug fix"}, "PR Feedback": {"General PR suggestions": "..., `xxx`...", "Code suggestions": [{"relevant file": "xxx.py", "suggestion content": "xxx [important]"} \n\t, {"suggestion number": 2, "relevant file": "yyy.py", "suggestion content": "yyy [incomp...'  # noqa: E501
+        expected_output = {
+            'PR Analysis': {
+                'Main theme': 'xxx',
+                'Type of PR': 'Bug fix'
+            },
+            'PR Feedback': {
+                'General PR suggestions': '..., `xxx`...',
+                'Code suggestions': [
+                    {
+                        'relevant file': 'xxx.py',
+                        'suggestion content': 'xxx [important]'
+                    }
+                ]
+            }
+        }
+        assert try_fix_json(review) == expected_output
+
+    def test_incomplete_code_suggestions_many_close_brackets(self):
+        review = '{"PR Analysis": {"Main theme": "xxx", "Type of PR": "Bug fix"}, "PR Feedback": {"General PR suggestions": "..., `xxx`...", "Code suggestions": [{"relevant file": "xxx.py", "suggestion content": "xxx [important]"} \n, {"suggestion number": 2, "relevant file": "yyy.py", "suggestion content": "yyy }, [}\n ,incomp.}  ,..'  # noqa: E501
+        expected_output = {
+            'PR Analysis': {
+                'Main theme': 'xxx',
+                'Type of PR': 'Bug fix'
+            },
+            'PR Feedback': {
+                'General PR suggestions': '..., `xxx`...',
+                'Code suggestions': [
+                    {
+                        'relevant file': 'xxx.py',
+                        'suggestion content': 'xxx [important]'
+                    }
+                ]
+            }
+        }
+        assert try_fix_json(review) == expected_output
+
+    def test_incomplete_code_suggestions_relevant_file(self):
+        review = '{"PR Analysis": {"Main theme": "xxx", "Type of PR": "Bug fix"}, "PR Feedback": {"General PR suggestions": "..., `xxx`...", "Code suggestions": [{"relevant file": "xxx.py", "suggestion content": "xxx [important]"}, {"suggestion number": 2, "relevant file": "yyy.p'  # noqa: E501
+        expected_output = {
+            'PR Analysis': {
+                'Main theme': 'xxx',
+                'Type of PR': 'Bug fix'
+            },
+            'PR Feedback': {
+                'General PR suggestions': '..., `xxx`...',
+                'Code suggestions': [
+                    {
+                        'relevant file': 'xxx.py',
+                        'suggestion content': 'xxx [important]'
+                    }
+                ]
+            }
+        }
+        assert try_fix_json(review) == expected_output

tests/unit/test_parse_code_suggestion.py

@@ -41,14 +41,6 @@ class TestParseCodeSuggestion:
         expected_output = "\n"  # modified to expect a newline character
         assert parse_code_suggestion(input_data) == expected_output
 
-    # Tests that function returns correct output when 'suggestion number' key has a non-integer value
-    def test_non_integer_suggestion_number(self):
-        input_data = {
-            "Suggestion number": "one",
-            "Description": "This is a suggestion"
-        }
-        expected_output = "   **Description:** This is a suggestion\n\n"
-        assert parse_code_suggestion(input_data) == expected_output
 
     # Tests that function returns correct output when 'before' or 'after' key has a non-string value
     def test_non_string_before_or_after(self):
@@ -64,7 +56,6 @@ class TestParseCodeSuggestion:
     # Tests that function returns correct output when input dictionary does not have 'code example' key
     def test_no_code_example_key(self):
         code_suggestions = {
-            'suggestion number': 1,
             'suggestion': 'Suggestion 1',
             'description': 'Description 1',
             'before': 'Before 1',
@@ -76,7 +67,6 @@ class TestParseCodeSuggestion:
     # Tests that function returns correct output when input dictionary has 'code example' key
     def test_with_code_example_key(self):
         code_suggestions = {
-            'suggestion number': 2,
             'suggestion': 'Suggestion 2',
             'description': 'Description 2',
             'code example': {