Update release notes

Enhancing error handling in PR review tools

.github/workflows/pr-agent-review.yaml

@@ -24,4 +24,7 @@ jobs:
           OPENAI_KEY: ${{ secrets.OPENAI_KEY }}
           OPENAI_ORG: ${{ secrets.OPENAI_ORG }} # optional
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PINECONE.API_KEY: ${{ secrets.PINECONE_API_KEY }}
+          PINECONE.ENVIRONMENT: ${{ secrets.PINECONE_ENVIRONMENT }}
+
 

Dockerfile.github_action_dockerhub

@@ -1 +1 @@
-FROM codiumai/pr-agent:github_action
+FROM codiumai/pr-agent:0.7-github_action

INSTALL.md

@@ -24,9 +24,15 @@ To request a review for a PR, or ask a question about a PR, you can run directly
 
 1. To request a review for a PR, run the following command:
 
+For GitHub:
 ```
 docker run --rm -it -e OPENAI.KEY=<your key> -e GITHUB.USER_TOKEN=<your token> codiumai/pr-agent --pr_url <pr_url> review
 ```
+For GitLab:
+```
+docker run --rm -it -e OPENAI.KEY=<your key> -e CONFIG.GIT_PROVIDER=gitlab -e GITLAB.PERSONAL_ACCESS_TOKEN=<your token> codiumai/pr-agent --pr_url <pr_url> review
+```
+For other git providers, update CONFIG.GIT_PROVIDER accordingly, and check the `pr_agent/settings/.secrets_template.toml` file for the environment variables expected names and values.
 
 2. To ask a question about a PR, run the following command:
 
@@ -354,7 +360,7 @@ PYTHONPATH="/PATH/TO/PROJECTS/pr-agent" python pr_agent/cli.py \
 ```
 WEBHOOK_SECRET=$(python -c "import secrets; print(secrets.token_hex(10))")
 ```
-3. Follow the instructions to build the Docker image, setup a secrets file and deploy on your own server from [Method 5](#method-5-run-as-a-github-app).
+3. Follow the instructions to build the Docker image, setup a secrets file and deploy on your own server from [Method 5](#method-5-run-as-a-github-app) steps 4-7.
 4. In the secrets file, fill in the following:
     - Your OpenAI key.
     - In the [gitlab] section, fill in personal_access_token and shared_secret. The access token can be a personal access token, or a group or project access token.
@@ -363,11 +369,5 @@ WEBHOOK_SECRET=$(python -c "import secrets; print(secrets.token_hex(10))")
 In the "Trigger" section, check the ‘comments’ and ‘merge request events’ boxes. 
 6. Test your installation by opening a merge request or commenting or a merge request using one of CodiumAI's commands.
 
----
 
-### Appendix - **Debugging LLM API Calls**  
+=======
-If you're testing your codium/pr-agent server, and need to see if calls were made successfully + the exact call logs, you can use the [LiteLLM Debugger tool](https://docs.litellm.ai/docs/debugging/hosted_debugging). 
-
-You can do this by setting `litellm_debugger=true` in configuration.toml. Your Logs will be viewable in real-time @ `admin.litellm.ai/<your_email>`. Set your email in the `.secrets.toml` under 'user_email'.
-
-<img src="./pics/debugger.png" width="800"/>

README.md

@@ -15,20 +15,22 @@ Making pull requests less painful with an AI agent
 </div>
 <div style="text-align:left;">
 
-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 PR feedback:
+CodiumAI `PR-Agent` is an open-source tool aiming to help developers review pull requests faster and more efficiently. It automatically analyzes the pull request and can provide several types of commands:
 
-**Auto Description (/describe)**: Automatically generating [PR description](https://github.com/Codium-ai/pr-agent/pull/229#issue-1860711415) - title, type, summary, code walkthrough and labels.
+‣ **Auto Description (`/describe`)**: Automatically generating [PR description](https://github.com/Codium-ai/pr-agent/pull/229#issue-1860711415) - title, type, summary, code walkthrough and labels.
 \
-**Auto Review (/review)**: [Adjustable feedback](https://github.com/Codium-ai/pr-agent/pull/229#issuecomment-1695022908) about the PR main theme, type, relevant tests, security issues, score, and various suggestions for the PR content.
+‣ **Auto Review (`/review`)**: [Adjustable feedback](https://github.com/Codium-ai/pr-agent/pull/229#issuecomment-1695022908) about the PR main theme, type, relevant tests, security issues, score, and various suggestions for the PR content.
 \
-**Question Answering (/ask ...)**: Answering [free-text questions](https://github.com/Codium-ai/pr-agent/pull/229#issuecomment-1695021332) about the PR.
+‣ **Question Answering (`/ask ...`)**: Answering [free-text questions](https://github.com/Codium-ai/pr-agent/pull/229#issuecomment-1695021332) about the PR.
 \
-**Code Suggestions (/improve)**: [Committable code suggestions](https://github.com/Codium-ai/pr-agent/pull/229#discussion_r1306919276) for improving the PR.
+‣ **Code Suggestions (`/improve`)**: [Committable code suggestions](https://github.com/Codium-ai/pr-agent/pull/229#discussion_r1306919276) for improving the PR.
 \
-**Update Changelog (/update_changelog)**: Automatically updating the CHANGELOG.md file with the [PR changes](https://github.com/Codium-ai/pr-agent/pull/168#discussion_r1282077645).
+‣ **Update Changelog (`/update_changelog`)**: Automatically updating the CHANGELOG.md file with the [PR changes](https://github.com/Codium-ai/pr-agent/pull/168#discussion_r1282077645).
+\
+‣ **Find similar issue (`/similar_issue`)**: Automatically retrieves and presents [similar issues](https://github.com/Alibaba-MIIL/ASL/issues/107).
 
 
-See the [usage guide](./Usage.md) for instructions how to run the different tools from [CLI](./Usage.md#working-from-a-local-repo-cli), or by [online usage](./Usage.md#online-usage).
+See the [usage guide](./Usage.md) for instructions how to run the different tools from [CLI](./Usage.md#working-from-a-local-repo-cli), or by [online usage](./Usage.md#online-usage), as well as additional details on optional commands and configurations.
 
 <h3>Example results:</h3>
 </div>
@@ -87,9 +89,8 @@ See the [usage guide](./Usage.md) for instructions how to run the different tool
 - [Overview](#overview)
 - [Try it now](#try-it-now)
 - [Installation](#installation)
-- [Usage guide](./Usage.md)
 - [How it works](#how-it-works)
-- [Why use PR-Agent](#why-use-pr-agent)
+- [Why use PR-Agent?](#why-use-pr-agent)
 - [Roadmap](#roadmap)
 </div>
 
@@ -100,11 +101,12 @@ See the [usage guide](./Usage.md) for instructions how to run the different tool
 |-------|---------------------------------------------|:------:|:------:|:---------:|:----------:|:----------:|:----------:|
 | TOOLS | Review                                      |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:       |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:    |
 |       | Ask                                         |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:          |   :white_check_mark:          | :white_check_mark: |  :white_check_mark:    |
-|       | Auto-Description                            |   :white_check_mark:    |   :white_check_mark:    |           |   :white_check_mark:    |   :white_check_mark:    | :white_check_mark:    |
+|       | Auto-Description                            |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:        |   :white_check_mark:    |   :white_check_mark:    | :white_check_mark:    |
-|       | Improve Code                                |   :white_check_mark:    |   :white_check_mark:    |           |   :white_check_mark:    |          |    :white_check_mark:    |
+|       | Improve Code                                |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:        |   :white_check_mark:    |          |    :white_check_mark:    |
-|       | ⮑ Extended                             |   :white_check_mark:    |   :white_check_mark:    |           |   :white_check_mark:    |          | :white_check_mark:    |
+|       | ⮑ Extended                             |   :white_check_mark:    |   :white_check_mark:    |        :white_check_mark:   |   :white_check_mark:    |          | :white_check_mark:    |
-|       | Reflect and Review                          |   :white_check_mark:    |                         |           |          |   :white_check_mark:    |    :white_check_mark:    |
+|       | Reflect and Review                          |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:        |          |   :white_check_mark:    |    :white_check_mark:    |
-|       | Update CHANGELOG.md                         |   :white_check_mark:    |                         |           |          |          |       |
+|       | Update CHANGELOG.md                         |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:        |          |          |       |
+|       | Find similar issue                          |   :white_check_mark:    |                         |                             |          |          |       |
 |       |                                             |        |        |      |      |      |
 | USAGE | CLI                                         |   :white_check_mark:    |   :white_check_mark:    |   :white_check_mark:       |   :white_check_mark:    |   :white_check_mark:    |
 |       | App / webhook                               |   :white_check_mark:    |   :white_check_mark:    |           |          |          |
@@ -182,7 +184,7 @@ Here are some advantages of PR-Agent:
 - [x] Support additional models, as a replacement for OpenAI (see [here](https://github.com/Codium-ai/pr-agent/pull/172))
 - [x] Develop additional logic for handling large PRs (see [here](https://github.com/Codium-ai/pr-agent/pull/229))
 - [ ] Add additional context to the prompt. For example, repo (or relevant files) summarization, with tools such a [ctags](https://github.com/universal-ctags/ctags)
-- [ ] PR-Agent for issues, and just for pull requests
+- [x] PR-Agent for issues
 - [ ] Adding more tools. Possible directions:
   - [x] PR description
   - [x] Inline code suggestions
@@ -199,4 +201,14 @@ Here are some advantages of PR-Agent:
 - [Aider - GPT powered coding in your terminal](https://github.com/paul-gauthier/aider)
 - [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)
+- [AI-Maintainer](https://github.com/merwanehamadi/AI-Maintainer)
+  
+## Links
+
+[![Join our Discord community](https://raw.githubusercontent.com/Codium-ai/codiumai-vscode-release/main/media/docs/Joincommunity.png)](https://discord.gg/kG35uSHDBc)
+
+- Discord community: https://discord.gg/kG35uSHDBc
+- CodiumAI site: https://codium.ai
+- Blog: https://www.codium.ai/blog/
+- Troubleshooting: https://www.codium.ai/blog/technical-faq-and-troubleshooting/
+- Support: support@codium.ai

RELEASE_NOTES.md

@@ -0,0 +1,25 @@
+## [Version 0.7] - 2023-09-20
+
+### Docker Tags
+- codiumai/pr-agent:0.7
+- codiumai/pr-agent:0.7-github_app
+- codiumai/pr-agent:0.7-bitbucket-app
+- codiumai/pr-agent:0.7-gitlab_webhook
+- codiumai/pr-agent:0.7-github_polling
+- codiumai/pr-agent:0.7-github_action
+ 
+### Added::Algo
+- New tool /similar_issue - Currently on GitHub app and CLI: indexes the issues in the repo, find the most similar issues to the target issue.
+- Describe markers: Empower the /describe tool with a templating capability (see more details in https://github.com/Codium-ai/pr-agent/pull/273).
+- New feature in the /review tool - added an estimated effort estimation to the review (https://github.com/Codium-ai/pr-agent/pull/306).
+
+### Added::Infrastructure
+- Implementation of a GitLab webhook.
+- Implementation of a BitBucket app.
+
+### Fixed
+- Protection against no code suggestions generated.
+- Resilience to repositories where the languages cannot be automatically detected.
+
+
+

Usage.md

@@ -50,12 +50,12 @@ When running from your local repo (CLI), your local configuration file will be u
 
 Examples for invoking the different tools via the CLI:
 
-- **Review**:       `python cli.py --pr_url=<pr_url>  /review`
+- **Review**:       `python cli.py --pr_url=<pr_url>  review`
-- **Describe**:     `python cli.py --pr_url=<pr_url>  /describe`
+- **Describe**:     `python cli.py --pr_url=<pr_url>  describe`
-- **Improve**:      `python cli.py --pr_url=<pr_url>  /improve`
+- **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"`
+- **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`
+- **Reflect**:      `python cli.py --pr_url=<pr_url>  reflect`
-- **Update Changelog**:      `python cli.py --pr_url=<pr_url>  /update_changelog`
+- **Update Changelog**:      `python cli.py --pr_url=<pr_url>  update_changelog`
 
 `<pr_url>` is the url of the relevant PR (for example: https://github.com/Codium-ai/pr-agent/pull/50).
 
@@ -149,15 +149,83 @@ TBD
 #### Changing a model
 See [here](pr_agent/algo/__init__.py) for the list of available models.
 
-To use Llama2 model, for example, set:
+#### Azure
+To use Azure, set: 
+```
+api_key = "" # your azure api key
+api_type = "azure"
+api_version = '2023-05-15'  # Check Azure documentation for the current API version
+api_base = ""  # The base URL for your Azure OpenAI resource. e.g. "https://<your resource name>.openai.azure.com"
+deployment_id = ""  # The deployment name you chose when you deployed the engine
+```
+in your .secrets.toml
+
+and 
 ```
 [config]
+model="" # the OpenAI model you've deployed on Azure (e.g. gpt-3.5-turbo)
+```
+in the configuration.toml 
+
+#### Huggingface
+
+**Local**  
+You can run Huggingface models locally through either [VLLM](https://docs.litellm.ai/docs/providers/vllm) or [Ollama](https://docs.litellm.ai/docs/providers/ollama)
+
+E.g. to use a new Huggingface model locally via Ollama, set:
+```
+[__init__.py]
+MAX_TOKENS = {
+    "model-name-on-ollama": <max_tokens>
+}
+e.g.
+MAX_TOKENS={
+    ...,
+    "llama2": 4096
+}
+
+
+[config] # in configuration.toml
+model = "ollama/llama2"
+
+[ollama] # in .secrets.toml
+api_base = ... # the base url for your huggingface inference endpoint 
+```
+
+**Inference Endpoints**
+
+To use a new model with Huggingface Inference Endpoints, for example, set:
+```
+[__init__.py]
+MAX_TOKENS = {
+    "model-name-on-huggingface": <max_tokens>
+}
+e.g.
+MAX_TOKENS={
+    ...,
+    "meta-llama/Llama-2-7b-chat-hf": 4096
+}
+[config] # in configuration.toml
+model = "huggingface/meta-llama/Llama-2-7b-chat-hf"
+
+[huggingface] # in .secrets.toml
+key = ... # your huggingface api key
+api_base = ... # the base url for your huggingface inference endpoint 
+```
+(you can obtain a Llama2 key from [here](https://replicate.com/replicate/llama-2-70b-chat/api))
+
+#### Replicate
+
+To use Llama2 model with Replicate, for example, set:
+```
+[config] # in configuration.toml
 model = "replicate/llama-2-70b-chat:2c1608e18606fad2812020dc541930f2d0495ce32eee50074220b87300bc16e1"
-[replicate]
+[replicate] # in .secrets.toml
 key = ...
 ```
 (you can obtain a Llama2 key from [here](https://replicate.com/replicate/llama-2-70b-chat/api))
 
+
 Also review the [AiHandler](pr_agent/algo/ai_handler.py) file for instruction how to set keys for other models.
 
 #### Extra instructions
@@ -179,4 +247,26 @@ And use the following settings (you have to replace the values) in .secrets.toml
 [azure_devops]
 org = "https://dev.azure.com/YOUR_ORGANIZATION/"
 pat = "YOUR_PAT_TOKEN"
-```
+```
+
+#### Similar issue tool
+
+[Example usage](https://github.com/Alibaba-MIIL/ASL/issues/107)
+
+<img src=./pics/similar_issue_tool.png width="768">
+
+To enable usage of the '**similar issue**' tool, you need to set the following keys in `.secrets.toml` (or in the relevant environment variables):
+```
+[pinecone]
+api_key = "..."
+environment = "..."
+```
+These parameters can be obtained by registering to [Pinecone](https://app.pinecone.io/?sessionType=signup/).
+
+- To invoke the 'similar issue' tool from **CLI**, run:
+`python3 cli.py --issue_url=... similar_issue`
+
+- To invoke the 'similar' issue tool via online usage, [comment](https://github.com/Codium-ai/pr-agent/issues/178#issuecomment-1716934893) on a PR:
+`/similar_issue`
+
+- You can also enable the 'similar issue' tool to run automatically when a new issue is opened, by adding it to the [pr_commands list in the github_app section](https://github.com/Codium-ai/pr-agent/blob/main/pr_agent/settings/configuration.toml#L66)

pr_agent/agent/pr_agent.py

@@ -9,6 +9,7 @@ from pr_agent.git_providers import get_git_provider
 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_similar_issue import PRSimilarIssue
 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
@@ -30,6 +31,7 @@ command2class = {
     "update_changelog": PRUpdateChangelog,
     "config": PRConfig,
     "settings": PRConfig,
+    "similar_issue": PRSimilarIssue,
 }
 
 commands = list(command2class.keys())

pr_agent/algo/__init__.py

@@ -1,4 +1,5 @@
 MAX_TOKENS = {
+    'text-embedding-ada-002': 8000,
     'gpt-3.5-turbo': 4000,
     'gpt-3.5-turbo-0613': 4000,
     'gpt-3.5-turbo-0301': 4000,
@@ -11,4 +12,5 @@ MAX_TOKENS = {
     'claude-2': 100000,
     'command-nightly': 4096,
     'replicate/llama-2-70b-chat:2c1608e18606fad2812020dc541930f2d0495ce32eee50074220b87300bc16e1': 4096,
+    'meta-llama/Llama-2-7b-chat-hf': 4096
 }

pr_agent/algo/ai_handler.py

@@ -1,13 +1,12 @@
 import logging
+import os
 
 import litellm
 import openai
 from litellm import acompletion
 from openai.error import APIError, RateLimitError, Timeout, TryAgain
 from retry import retry
-
 from pr_agent.config_loader import get_settings
-
 OPENAI_RETRIES = 5
 
 
@@ -26,7 +25,11 @@ class AiHandler:
         try:
             openai.api_key = get_settings().openai.key
             litellm.openai_key = get_settings().openai.key
-            litellm.debugger = get_settings().litellm.debugger
+            if get_settings().get("litellm.use_client"):
+                litellm_token = get_settings().get("litellm.LITELLM_TOKEN")
+                assert litellm_token, "LITELLM_TOKEN is required"
+                os.environ["LITELLM_TOKEN"] = litellm_token
+                litellm.use_client = True
             self.azure = False
             if get_settings().get("OPENAI.ORG", None):
                 litellm.organization = get_settings().openai.org
@@ -48,8 +51,8 @@ class AiHandler:
                 litellm.replicate_key = get_settings().replicate.key
             if get_settings().get("HUGGINGFACE.KEY", None):
                 litellm.huggingface_key = get_settings().huggingface.key
-            if get_settings().get("LITELLM.DEBUGGER") and get_settings().get("LITELLM.EMAIL"):
+                if get_settings().get("HUGGINGFACE.API_BASE", None):
-                litellm.email = get_settings().get("LITELLM.EMAIL", None)
+                    litellm.api_base = get_settings().huggingface.api_base
         except AttributeError as e:
             raise ValueError("OpenAI key is required") from e
 

pr_agent/algo/language_handler.py

@@ -42,6 +42,11 @@ def sort_files_by_main_languages(languages: Dict, files: list):
     files_sorted = []
     rest_files = {}
 
+    # if no languages detected, put all files in the "Other" category
+    if not languages:
+        files_sorted = [({"language": "Other", "files": list(files_filtered)})]
+        return files_sorted
+
     main_extensions_flat = []
     for ext in main_extensions:
         main_extensions_flat.extend(ext)

pr_agent/algo/token_handler.py

@@ -21,7 +21,7 @@ class TokenHandler:
       method.
     """
 
-    def __init__(self, pr, vars: dict, system, user):
+    def __init__(self, pr=None, vars: dict = {}, system="", user=""):
         """
         Initializes the TokenHandler object.
 
@@ -32,7 +32,8 @@ class TokenHandler:
         - user: The user string.
         """
         self.encoder = get_token_encoder()
-        self.prompt_tokens = self._get_system_user_tokens(pr, self.encoder, vars, system, user)
+        if pr is not None:
+            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):
         """

pr_agent/algo/utils.py

@@ -20,7 +20,7 @@ def get_setting(key: str) -> Any:
     except Exception:
         return global_settings.get(key, None)
 
-def convert_to_markdown(output_data: dict) -> str:
+def convert_to_markdown(output_data: dict, gfm_supported: bool=True) -> str:
     """
     Convert a dictionary of data into markdown format.
     Args:
@@ -42,6 +42,7 @@ def convert_to_markdown(output_data: dict) -> str:
         "General suggestions": "💡",
         "Insights from user's answers": "📝",
         "Code feedback": "🤖",
+        "Estimated effort to review [1-5]": "⏱️",
     }
 
     for key, value in output_data.items():
@@ -49,11 +50,14 @@ def convert_to_markdown(output_data: dict) -> str:
             continue
         if isinstance(value, dict):
             markdown_text += f"## {key}\n\n"
-            markdown_text += convert_to_markdown(value)
+            markdown_text += convert_to_markdown(value, gfm_supported)
         elif isinstance(value, list):
             emoji = emojis.get(key, "")
             if key.lower() == 'code feedback':
-                markdown_text += f"\n\n- **<details><summary> { emoji } Code feedback:**</summary>\n\n"
+                if gfm_supported:
+                    markdown_text += f"\n\n- **<details><summary> { emoji } Code feedback:**</summary>\n\n"
+                else:
+                    markdown_text += f"\n\n- **{emoji} Code feedback:**\n\n"
             else:
                 markdown_text += f"- {emoji} **{key}:**\n\n"
             for item in value:
@@ -62,7 +66,10 @@ def convert_to_markdown(output_data: dict) -> str:
                 elif item:
                     markdown_text += f"  - {item}\n"
             if key.lower() == 'code feedback':
-                markdown_text += "</details>\n\n"
+                if gfm_supported:
+                    markdown_text += "</details>\n\n"
+                else:
+                    markdown_text += "\n\n"
         elif value != 'n/a':
             emoji = emojis.get(key, "")
             markdown_text += f"- {emoji} **{key}:** {value}\n"
@@ -168,7 +175,7 @@ def fix_json_escape_char(json_message=None):
     Raises:
         None
 
-    """    
+    """
     try:
         result = json.loads(json_message)
     except Exception as e:
@@ -195,7 +202,7 @@ def convert_str_to_datetime(date_str):
     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)
 

pr_agent/cli.py

@@ -17,6 +17,7 @@ For example:
 - cli.py --pr_url=... improve
 - cli.py --pr_url=... ask "write me a poem about this PR"
 - cli.py --pr_url=... reflect
+- cli.py --issue_url=... similar_issue
 
 Supported commands:
 -review / review_pr - Add a review that includes a summary of the PR and specific suggestions for improvement.
@@ -37,14 +38,22 @@ Configuration:
 To edit any configuration parameter from 'configuration.toml', just add -config_path=<value>.
 For example: 'python cli.py --pr_url=... review --pr_reviewer.extra_instructions="focus on the file: ..."'
 """)
-    parser.add_argument('--pr_url', type=str, help='The URL of the PR to review', required=True)
+    parser.add_argument('--pr_url', type=str, help='The URL of the PR to review', default=None)
+    parser.add_argument('--issue_url', type=str, help='The URL of the Issue to review', default=None)
     parser.add_argument('command', type=str, help='The', choices=commands, default='review')
     parser.add_argument('rest', nargs=argparse.REMAINDER, default=[])
     args = parser.parse_args(inargs)
+    if not args.pr_url and not args.issue_url:
+        parser.print_help()
+        return
+
     logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
     command = args.command.lower()
     get_settings().set("CONFIG.CLI_MODE", True)
-    result = asyncio.run(PRAgent().handle_request(args.pr_url, command + " " + " ".join(args.rest)))
+    if args.issue_url:
+        result = asyncio.run(PRAgent().handle_request(args.issue_url, command + " " + " ".join(args.rest)))
+    else:
+        result = asyncio.run(PRAgent().handle_request(args.pr_url, command + " " + " ".join(args.rest)))
     if not result:
         parser.print_help()
 

pr_agent/git_providers/azuredevops_provider.py

@@ -38,7 +38,8 @@ class AzureDevopsProvider:
             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', 'remove_initial_comment']:
+        if capability in ['get_issue_comments', 'create_inline_comment', 'publish_inline_comments', 'get_labels',
+                          'remove_initial_comment', 'gfm_markdown']:
             return False
         return True
 

pr_agent/git_providers/bitbucket_provider.py

@@ -7,6 +7,7 @@ import requests
 from atlassian.bitbucket import Cloud
 from starlette_context import context
 
+from ..algo.pr_processing import clip_tokens, find_line_number_of_relevant_line_in_file
 from ..config_loader import get_settings
 from .git_provider import FilePatchInfo, GitProvider
 
@@ -35,9 +36,8 @@ class BitbucketProvider(GitProvider):
         self.incremental = incremental
         if pr_url:
             self.set_pr(pr_url)
-        self.bitbucket_comment_api_url = self.pr._BitbucketBase__data["links"][
+        self.bitbucket_comment_api_url = self.pr._BitbucketBase__data["links"]["comments"]["href"]
-            "comments"
+        self.bitbucket_pull_request_api_url = self.pr._BitbucketBase__data["links"]['self']['href']
-        ]["href"]
 
     def get_repo_settings(self):
         try:
@@ -101,12 +101,7 @@ class BitbucketProvider(GitProvider):
             return False
 
     def is_supported(self, capability: str) -> bool:
-        if capability in [
+        if capability in ['get_issue_comments', 'publish_inline_comments', 'get_labels', 'gfm_markdown']:
-            "get_issue_comments",
-            "create_inline_comment",
-            "publish_inline_comments",
-            "get_labels",
-        ]:
             return False
         return True
 
@@ -151,17 +146,30 @@ class BitbucketProvider(GitProvider):
         except Exception as e:
             logging.exception(f"Failed to remove temp comments, error: {e}")
 
-    def publish_inline_comment(
+
-        self, comment: str, from_line: int, to_line: int, file: str
+    # funtion to create_inline_comment
-    ):
+    def create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
-        payload = json.dumps(
+        position, absolute_position = find_line_number_of_relevant_line_in_file(self.get_diff_files(), relevant_file.strip('`'), relevant_line_in_file)
-            {
+        if position == -1:
-                "content": {
+            if get_settings().config.verbosity_level >= 2:
-                    "raw": comment,
+                logging.info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
-                },
+            subject_type = "FILE"
-                "inline": {"to": from_line, "path": file},
+        else:
-            }
+            subject_type = "LINE"
-        )
+        path = relevant_file.strip()
+        return dict(body=body, path=path, position=absolute_position) if subject_type == "LINE" else {}
+
+
+    def publish_inline_comment(self, comment: str, from_line: int, file: str):
+        payload = json.dumps( {
+            "content": {
+                "raw": comment,
+            },
+            "inline": {
+                "to": from_line,
+                "path": file
+            },
+        })
         response = requests.request(
             "POST", self.bitbucket_comment_api_url, data=payload, headers=self.headers
         )
@@ -169,9 +177,7 @@ class BitbucketProvider(GitProvider):
 
     def publish_inline_comments(self, comments: list[dict]):
         for comment in comments:
-            self.publish_inline_comment(
+            self.publish_inline_comment(comment['body'], comment['start_line'], comment['path'])
-                comment["body"], comment["start_line"], comment["line"], comment["path"]
-            )
 
     def get_title(self):
         return self.pr.title
@@ -238,16 +244,22 @@ class BitbucketProvider(GitProvider):
 
     def get_commit_messages(self):
         return ""  # not implemented yet
+    
+    # bitbucket does not support labels
+    def publish_description(self, pr_title: str, description: str):
+        payload = json.dumps({
+            "description": description,
+            "title": pr_title
 
-    def publish_description(self, pr_title: str, pr_body: str):
+            })
-        pass
-    def create_inline_comment(
-        self, body: str, relevant_file: str, relevant_line_in_file: str
-    ):
-        pass
 
-    def publish_labels(self, labels):
+        response = requests.request("PUT", self.bitbucket_pull_request_api_url, headers=self.headers, data=payload)
-        pass
+        return response
 
+    # bitbucket does not support labels
+    def publish_labels(self, pr_types: list):
+        pass
+    
+    # bitbucket does not support labels
     def get_labels(self):
         pass

pr_agent/git_providers/codecommit_client.py

@@ -54,11 +54,16 @@ class CodeCommitClient:
     def __init__(self):
         self.boto_client = None
 
+    def is_supported(self, capability: str) -> bool:
+        if capability in ["gfm_markdown"]:
+            return False
+        return True
+
     def _connect_boto_client(self):
         try:
             self.boto_client = boto3.client("codecommit")
         except Exception as e:
-            raise ValueError(f"Failed to connect to AWS CodeCommit: {e}")
+            raise ValueError(f"Failed to connect to AWS CodeCommit: {e}") from e
 
     def get_differences(self, repo_name: int, destination_commit: str, source_commit: str):
         """

pr_agent/git_providers/codecommit_provider.py

@@ -74,6 +74,7 @@ class CodeCommitProvider(GitProvider):
             "create_inline_comment",
             "publish_inline_comments",
             "get_labels",
+            "gfm_markdown"
         ]:
             return False
         return True

pr_agent/git_providers/gerrit_provider.py

@@ -115,7 +115,14 @@ def adopt_to_gerrit_message(message):
     lines = message.splitlines()
     buf = []
     for line in lines:
-        line = line.replace("*", "").replace("``", "`")
+        # remove markdown formatting
+        line = (line.replace("*", "")
+                .replace("``", "`")
+                .replace("<details>", "")
+                .replace("</details>", "")
+                .replace("<summary>", "")
+                .replace("</summary>", ""))
+
         line = line.strip()
         if line.startswith('#'):
             buf.append("\n" +
@@ -219,10 +226,12 @@ class GerritProvider(GitProvider):
         return [self.repo.head.commit.message]
 
     def get_repo_settings(self):
-        """
+        try:
-        TODO: Implement support of .pr_agent.toml
+            with open(self.repo_path / ".pr_agent.toml", 'rb') as f:
-        """
+                contents = f.read()
-        return ""
+            return contents
+        except OSError:
+            return b""
 
     def get_diff_files(self) -> list[FilePatchInfo]:
         diffs = self.repo.head.commit.diff(
@@ -304,7 +313,8 @@ class GerritProvider(GitProvider):
             # 'get_issue_comments',
             'create_inline_comment',
             'publish_inline_comments',
-            'get_labels'
+            'get_labels',
+            'gfm_markdown'
         ]:
             return False
         return True

pr_agent/git_providers/git_provider.py

@@ -132,6 +132,10 @@ def get_main_pr_language(languages, files) -> str:
     Get the main language of the commit. Return an empty string if cannot determine.
     """
     main_language_str = ""
+    if not languages:
+        logging.info("No languages detected")
+        return main_language_str
+
     try:
         top_language = max(languages, key=languages.get).lower()
 

pr_agent/git_providers/github_provider.py

@@ -32,7 +32,7 @@ class GithubProvider(GitProvider):
         self.diff_files = None
         self.git_files = None
         self.incremental = incremental
-        if pr_url:
+        if pr_url and 'pull' in pr_url:
             self.set_pr(pr_url)
             self.last_commit_id = list(self.pr.get_commits())[-1]
 
@@ -309,6 +309,35 @@ class GithubProvider(GitProvider):
 
         return repo_name, pr_number
 
+    @staticmethod
+    def _parse_issue_url(issue_url: str) -> Tuple[str, int]:
+        parsed_url = urlparse(issue_url)
+
+        if 'github.com' not in parsed_url.netloc:
+            raise ValueError("The provided URL is not a valid GitHub URL")
+
+        path_parts = parsed_url.path.strip('/').split('/')
+        if 'api.github.com' in parsed_url.netloc:
+            if len(path_parts) < 5 or path_parts[3] != 'issues':
+                raise ValueError("The provided URL does not appear to be a GitHub ISSUE URL")
+            repo_name = '/'.join(path_parts[1:3])
+            try:
+                issue_number = int(path_parts[4])
+            except ValueError as e:
+                raise ValueError("Unable to convert issue number to integer") from e
+            return repo_name, issue_number
+
+        if len(path_parts) < 4 or path_parts[2] != 'issues':
+            raise ValueError("The provided URL does not appear to be a GitHub PR issue")
+
+        repo_name = '/'.join(path_parts[:2])
+        try:
+            issue_number = int(path_parts[3])
+        except ValueError as e:
+            raise ValueError("Unable to convert issue number to integer") from e
+
+        return repo_name, issue_number
+
     def _get_github_client(self):
         deployment_type = get_settings().get("GITHUB.DEPLOYMENT_TYPE", "user")
 

pr_agent/git_providers/gitlab_provider.py

@@ -43,7 +43,7 @@ class GitLabProvider(GitProvider):
         self.incremental = incremental
 
     def is_supported(self, capability: str) -> bool:
-        if capability in ['get_issue_comments', 'create_inline_comment', 'publish_inline_comments']:
+        if capability in ['get_issue_comments', 'create_inline_comment', 'publish_inline_comments', 'gfm_markdown']:
             return False
         return True
 

pr_agent/git_providers/local_git_provider.py

@@ -56,7 +56,8 @@ class LocalGitProvider(GitProvider):
             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']:
+        if capability in ['get_issue_comments', 'create_inline_comment', 'publish_inline_comments', 'get_labels',
+                          'gfm_markdown']:
             return False
         return True
 

pr_agent/servers/github_action_runner.py

@@ -12,8 +12,8 @@ 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_KEY = os.environ.get('OPENAI_KEY') or os.environ.get('OPENAI.KEY')
-    OPENAI_ORG = os.environ.get('OPENAI_ORG')
+    OPENAI_ORG = os.environ.get('OPENAI_ORG') or os.environ.get('OPENAI.ORG')
     GITHUB_TOKEN = os.environ.get('GITHUB_TOKEN')
     get_settings().set("CONFIG.PUBLISH_OUTPUT_PROGRESS", False)
 
@@ -61,12 +61,21 @@ async def run_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")
+                is_pr = False
-                if pr_url:
+                # check if issue is pull request
+                if event_payload.get("issue", {}).get("pull_request"):
+                    url = event_payload.get("issue", {}).get("pull_request", {}).get("url")
+                    is_pr = True
+                else:
+                    url = event_payload.get("issue", {}).get("url")
+                if url:
                     body = comment_body.strip().lower()
                     comment_id = event_payload.get("comment", {}).get("id")
-                    provider = get_git_provider()(pr_url=pr_url)
+                    provider = get_git_provider()(pr_url=url)
-                    await PRAgent().handle_request(pr_url, body, notify=lambda: provider.add_eyes_reaction(comment_id))
+                    if is_pr:
+                        await PRAgent().handle_request(url, body, notify=lambda: provider.add_eyes_reaction(comment_id))
+                    else:
+                        await PRAgent().handle_request(url, body)
 
 
 if __name__ == '__main__':

pr_agent/settings/.secrets_template.toml

@@ -16,6 +16,10 @@ key = ""  # Acquire through https://platform.openai.com
 #deployment_id = ""  # The deployment name you chose when you deployed the engine
 #fallback_deployments = []  # For each fallback model specified in configuration.toml in the [config] section, specify the appropriate deployment_id
 
+[pinecone]
+api_key = "..."
+environment = "gcp-starter"
+
 [anthropic]
 key = "" # Optional, uncomment if you want to use Anthropic. Acquire through https://www.anthropic.com/
 
@@ -24,6 +28,14 @@ key = "" # Optional, uncomment if you want to use Cohere. Acquire through https:
 
 [replicate]
 key = "" # Optional, uncomment if you want to use Replicate. Acquire through https://replicate.com/
+
+[huggingface]
+key = "" # Optional, uncomment if you want to use Huggingface Inference API. Acquire through https://huggingface.co/docs/api-inference/quicktour
+api_base = "" # the base url for your huggingface inference endpoint 
+
+[ollama]
+api_base = "" # the base url for your huggingface inference endpoint 
+
 [github]
 # ---- Set the following only for deployment type == "user"
 user_token = ""  # A GitHub personal access token with 'repo' scope.
@@ -43,5 +55,12 @@ webhook_secret = "<WEBHOOK SECRET>"  # Optional, may be commented out.
 personal_access_token = ""
 
 [bitbucket]
-# Bitbucket personal bearer token
+# For Bitbucket personal/repository bearer token
 bearer_token = ""
+
+# For Bitbucket app
+app_key = ""
+base_url = ""
+
+[litellm]
+LITELLM_TOKEN = "" # see https://docs.litellm.ai/docs/debugging/hosted_debugging for details and instructions on how to get a token

pr_agent/settings/configuration.toml

@@ -11,12 +11,14 @@ ai_timeout=180
 max_description_tokens = 500
 max_commits_tokens = 500
 secret_provider="google_cloud_storage"
+cli_mode=false
 
 [pr_reviewer] # /review #
 require_focused_review=false
 require_score_review=false
 require_tests_review=true
 require_security_review=true
+require_estimate_effort_to_review=true
 num_code_suggestions=4
 inline_code_comments = false
 ask_and_reflect=false
@@ -24,10 +26,14 @@ automatic_review=true
 extra_instructions = ""
 
 [pr_description] # /describe #
+publish_labels=true
 publish_description_as_comment=false
 add_original_user_description=false
 keep_original_user_title=false
 extra_instructions = ""
+# markers
+use_description_markers=false
+include_generated_by_header=true
 
 [pr_questions] # /ask #
 
@@ -96,5 +102,14 @@ polling_interval_seconds = 30
 # patch_server_token = ""
 
 [litellm]
-debugger=false
+#use_client = false
-#email="youremail@example.com"
+
+[pr_similar_issue]
+skip_comments = false
+force_update_dataset = false
+max_issues_to_scan = 500
+
+[pinecone]
+# fill and place in .secrets.toml
+#api_key = ...
+# environment = "gcp-starter"

pr_agent/settings/pr_reviewer_prompts.toml

@@ -85,6 +85,14 @@ PR Analysis:
       code diff changes are too scattered, then the PR is not focused. Explain
       your answer shortly.
 {%- endif %}
+{%- if require_estimate_effort_to_review %}
+  Estimated effort to review [1-5]:
+    type: string
+    description: >-
+      Estimate, on a scale of 1-5 (inclusive), the time and effort required to review this PR by an experienced and knowledgeable developer. 1 means short and easy review , 5 means long and hard review.
+      Take into account the size, complexity, quality, and the needed changes of the PR code diff.
+      Explain your answer shortly (1-2 sentences).
+{%- endif %}
 PR Feedback:
   General suggestions:
     type: string

pr_agent/tools/pr_code_suggestions.py

@@ -48,27 +48,33 @@ class PRCodeSuggestions:
                                           get_settings().pr_code_suggestions_prompt.user)
 
     async def run(self):
-        logging.info('Generating code suggestions for PR...')
+        try:
-        if get_settings().config.publish_output:
+            logging.info('Generating code suggestions for PR...')
-            self.git_provider.publish_comment("Preparing review...", is_temporary=True)
+            if get_settings().config.publish_output:
+                self.git_provider.publish_comment("Preparing review...", is_temporary=True)
 
-        logging.info('Preparing PR review...')
+            logging.info('Preparing PR review...')
-        if not self.is_extended:
+            if not self.is_extended:
-            await retry_with_fallback_models(self._prepare_prediction)
+                await retry_with_fallback_models(self._prepare_prediction)
-            data = self._prepare_pr_code_suggestions()
+                data = self._prepare_pr_code_suggestions()
-        else:
+            else:
-            data = await retry_with_fallback_models(self._prepare_prediction_extended)
+                data = await retry_with_fallback_models(self._prepare_prediction_extended)
+            if (not data) or (not 'Code suggestions' in data):
+                logging.info('No code suggestions found for PR.')
+                return
 
-        if (not self.is_extended and get_settings().pr_code_suggestions.rank_suggestions) or \
+            if (not self.is_extended and get_settings().pr_code_suggestions.rank_suggestions) or \
-                (self.is_extended and get_settings().pr_code_suggestions.rank_extended_suggestions):
+                    (self.is_extended and get_settings().pr_code_suggestions.rank_extended_suggestions):
-            logging.info('Ranking Suggestions...')
+                logging.info('Ranking Suggestions...')
-            data['Code suggestions'] = await self.rank_suggestions(data['Code suggestions'])
+                data['Code suggestions'] = await self.rank_suggestions(data['Code suggestions'])
 
-        if get_settings().config.publish_output:
+            if get_settings().config.publish_output:
-            logging.info('Pushing PR review...')
+                logging.info('Pushing PR review...')
-            self.git_provider.remove_initial_comment()
+                self.git_provider.remove_initial_comment()
-            logging.info('Pushing inline code suggestions...')
+                logging.info('Pushing inline code suggestions...')
-            self.push_inline_code_suggestions(data)
+                self.push_inline_code_suggestions(data)
+        except Exception as e:
+            logging.error(f"Failed to generate code suggestions for PR, error: {e}")
 
     async def _prepare_prediction(self, model: str):
         logging.info('Getting PR diff...')

pr_agent/tools/pr_description.py

@@ -1,5 +1,6 @@
 import copy
 import json
+import re
 import logging
 from typing import List, Tuple
 
@@ -28,6 +29,7 @@ class PRDescription:
         self.main_pr_language = get_main_pr_language(
             self.git_provider.get_languages(), self.git_provider.get_files()
         )
+        self.pr_id = f"{self.git_provider.repo}/{self.git_provider.pr_num}"
 
         # Initialize the AI handler
         self.ai_handler = AiHandler()
@@ -61,27 +63,44 @@ class PRDescription:
         """
         Generates a PR description using an AI model and publishes it to the PR.
         """
-        logging.info('Generating a PR description...')
+
-        if get_settings().config.publish_output:
+        try:
-            self.git_provider.publish_comment("Preparing pr description...", is_temporary=True)
+            logging.info(f"Generating a PR description {self.pr_id}")
-        
+            if get_settings().config.publish_output:
-        await retry_with_fallback_models(self._prepare_prediction)
+                self.git_provider.publish_comment("Preparing pr description...", is_temporary=True)
-        
+
-        logging.info('Preparing answer...')
+            await retry_with_fallback_models(self._prepare_prediction)
-        pr_title, pr_body, pr_types, markdown_text = self._prepare_pr_answer()
+
-        
+            logging.info(f"Preparing answer {self.pr_id}")
-        if get_settings().config.publish_output:
+            if self.prediction:
-            logging.info('Pushing answer...')
+                self._prepare_data()
-            if get_settings().pr_description.publish_description_as_comment:
-                self.git_provider.publish_comment(markdown_text)
             else:
-                self.git_provider.publish_description(pr_title, pr_body)
+                return None
-                if self.git_provider.is_supported("get_labels"):
+
-                    current_labels = self.git_provider.get_labels()
+            pr_labels = []
-                    if current_labels is None:
+            if get_settings().pr_description.publish_labels:
-                        current_labels = []
+                pr_labels = self._prepare_labels()
-                    self.git_provider.publish_labels(pr_types + current_labels)
+
-            self.git_provider.remove_initial_comment()
+            if get_settings().pr_description.use_description_markers:
+                pr_title, pr_body = self._prepare_pr_answer_with_markers()
+            else:
+                pr_title, pr_body,  = self._prepare_pr_answer()
+            full_markdown_description = f"## Title\n\n{pr_title}\n\n___\n{pr_body}"
+
+            if get_settings().config.publish_output:
+                logging.info(f"Pushing answer {self.pr_id}")
+                if get_settings().pr_description.publish_description_as_comment:
+                    self.git_provider.publish_comment(full_markdown_description)
+                else:
+                    self.git_provider.publish_description(pr_title, pr_body)
+                    if get_settings().pr_description.publish_labels and 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_labels + current_labels)
+                self.git_provider.remove_initial_comment()
+        except Exception as e:
+            logging.error(f"Error generating PR description {self.pr_id}: {e}")
         
         return ""
 
@@ -99,9 +118,12 @@ class PRDescription:
             Any exceptions raised by the 'get_pr_diff' and '_get_prediction' functions.
 
         """
-        logging.info('Getting PR diff...')
+        if get_settings().pr_description.use_description_markers and 'pr_agent:' not in self.user_description:
+            return None
+
+        logging.info(f"Getting PR diff {self.pr_id}")
         self.patches_diff = get_pr_diff(self.git_provider, self.token_handler, model)
-        logging.info('Getting AI prediction...')
+        logging.info(f"Getting AI prediction {self.pr_id}")
         self.prediction = await self._get_prediction(model)
 
     async def _get_prediction(self, model: str) -> str:
@@ -134,34 +156,71 @@ class PRDescription:
 
         return response
 
-    def _prepare_pr_answer(self) -> Tuple[str, str, List[str], str]:
+
+    def _prepare_data(self):
+        # Load the AI prediction data into a dictionary
+        self.data = load_yaml(self.prediction.strip())
+
+        if get_settings().pr_description.add_original_user_description and self.user_description:
+            self.data["User Description"] = self.user_description
+
+
+    def _prepare_labels(self) -> List[str]:
+        pr_types = []
+
+        # 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 self.data:
+            if type(self.data['PR Type']) == list:
+                pr_types = self.data['PR Type']
+            elif type(self.data['PR Type']) == str:
+                pr_types = self.data['PR Type'].split(',')
+
+        return pr_types
+
+    def _prepare_pr_answer_with_markers(self) -> Tuple[str, str]:
+        logging.info(f"Using description marker replacements {self.pr_id}")
+        title = self.vars["title"]
+        body = self.user_description
+        if get_settings().pr_description.include_generated_by_header:
+            ai_header = f"### 🤖 Generated by PR Agent at {self.git_provider.last_commit_id.sha}\n\n"
+        else:
+            ai_header = ""
+
+        ai_summary = self.data.get('PR Description')
+        if ai_summary and not re.search(r'<!--\s*pr_agent:summary\s*-->', body):
+            summary = f"{ai_header}{ai_summary}"
+            body = body.replace('pr_agent:summary', summary)
+
+        if not re.search(r'<!--\s*pr_agent:walkthrough\s*-->', body):
+            ai_walkthrough = self.data.get('PR Main Files Walkthrough')
+            if ai_walkthrough:
+                walkthrough = str(ai_header)
+                for file in ai_walkthrough:
+                    filename = file['filename'].replace("'", "`")
+                    description = file['changes in file'].replace("'", "`")
+                    walkthrough += f'- `{filename}`: {description}\n'
+
+                body = body.replace('pr_agent:walkthrough', walkthrough)
+
+        return title, body
+
+    def _prepare_pr_answer(self) -> Tuple[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_body: a string containing the PR description 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. used for publishing a comment
         """
-        # Load the AI prediction data into a dictionary
-        data = load_yaml(self.prediction.strip())
 
-        if get_settings().pr_description.add_original_user_description and self.user_description:
+        # Iterate over the dictionary items and append the key and value to 'markdown_text' in a markdown format
-            data["User Description"] = self.user_description
+        markdown_text = ""
-
+        for key, value in self.data.items():
-        # Initialization
+            markdown_text += f"## {key}\n\n"
-        pr_types = []
+            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:
-            if type(data['PR Type']) == list:
-                pr_types = data['PR Type']
-            elif type(data['PR Type']) == str:
-                pr_types = data['PR Type'].split(',')
 
         # Remove the 'PR Title' key from the dictionary
-        ai_title = data.pop('PR Title')
+        ai_title = self.data.pop('PR Title', self.vars["title"])
         if get_settings().pr_description.keep_original_user_title:
             # Assign the original PR title to the 'title' variable
             title = self.vars["title"]
@@ -172,25 +231,27 @@ class PRDescription:
         # 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'
         pr_body = ""
-        for idx, (key, value) in enumerate(data.items()):
+        for idx, (key, value) in enumerate(self.data.items()):
             pr_body += f"## {key}:\n"
             if 'walkthrough' in key.lower():
                 # for filename, description in value.items():
+                if self.git_provider.is_supported("gfm_markdown"):
+                    pr_body += "<details> <summary>files:</summary>\n\n"
                 for file in value:
                     filename = file['filename'].replace("'", "`")
                     description = file['changes in file']
                     pr_body += f'`{filename}`: {description}\n'
+                if self.git_provider.is_supported("gfm_markdown"):
+                    pr_body +="</details>\n"
             else:
                 # if the value is a list, join its items by comma
                 if type(value) == list:
                     value = ', '.join(v for v in value)
                 pr_body += f"{value}\n"
-            if idx < len(data) - 1:
+            if idx < len(self.data) - 1:
                 pr_body += "\n___\n"
 
-        markdown_text = f"## Title\n\n{title}\n\n___\n{pr_body}"
-
         if get_settings().config.verbosity_level >= 2:
             logging.info(f"title:\n{title}\n{pr_body}")
 
-        return title, pr_body, pr_types, markdown_text
+        return title, pr_body

pr_agent/tools/pr_reviewer.py

@@ -59,6 +59,7 @@ class PRReviewer:
             "require_tests": get_settings().pr_reviewer.require_tests_review,
             "require_security": get_settings().pr_reviewer.require_security_review,
             "require_focused": get_settings().pr_reviewer.require_focused_review,
+            "require_estimate_effort_to_review": get_settings().pr_reviewer.require_estimate_effort_to_review,
             'num_code_suggestions': get_settings().pr_reviewer.num_code_suggestions,
             'question_str': question_str,
             'answer_str': answer_str,
@@ -94,28 +95,32 @@ class PRReviewer:
         """
         Review the pull request and generate feedback.
         """
-        if self.is_auto and not get_settings().pr_reviewer.automatic_review:
-            logging.info(f'Automatic review is disabled {self.pr_url}')
-            return None
 
-        logging.info(f'Reviewing PR: {self.pr_url} ...')
+        try:
+            if self.is_auto and not get_settings().pr_reviewer.automatic_review:
+                logging.info(f'Automatic review is disabled {self.pr_url}')
+                return None
 
-        if get_settings().config.publish_output:
+            logging.info(f'Reviewing PR: {self.pr_url} ...')
-            self.git_provider.publish_comment("Preparing review...", is_temporary=True)
+
-    
+            if get_settings().config.publish_output:
-        await retry_with_fallback_models(self._prepare_prediction)
+                self.git_provider.publish_comment("Preparing review...", is_temporary=True)
-    
+
-        logging.info('Preparing PR review...')
+            await retry_with_fallback_models(self._prepare_prediction)
-        pr_comment = self._prepare_pr_review()
+
-    
+            logging.info('Preparing PR review...')
-        if get_settings().config.publish_output:
+            pr_comment = self._prepare_pr_review()
-            logging.info('Pushing PR review...')
+
-            self.git_provider.publish_comment(pr_comment)
+            if get_settings().config.publish_output:
-            self.git_provider.remove_initial_comment()
+                logging.info('Pushing PR review...')
-        
+                self.git_provider.publish_comment(pr_comment)
-            if get_settings().pr_reviewer.inline_code_comments:
+                self.git_provider.remove_initial_comment()
-                logging.info('Pushing inline code comments...')
+
-                self._publish_inline_code_comments()
+                if get_settings().pr_reviewer.inline_code_comments:
+                    logging.info('Pushing inline code comments...')
+                    self._publish_inline_code_comments()
+        except Exception as e:
+            logging.error(f"Failed to review PR: {e}")
 
     async def _prepare_prediction(self, model: str) -> None:
         """
@@ -214,7 +219,7 @@ class PRReviewer:
                 "⏮️ 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)
+        markdown_text = convert_to_markdown(data, self.git_provider.is_supported("gfm_markdown"))
         user = self.git_provider.get_user_id()
 
         # Add help text if not in CLI mode
@@ -266,7 +271,7 @@ class PRReviewer:
                 self.git_provider.publish_inline_comment(content, relevant_file, relevant_line_in_file)
 
         if comments:
-            self.git_provider.publish_inline_comments(comments)
+                self.git_provider.publish_inline_comments(comments)
 
     def _get_user_answers(self) -> Tuple[str, str]:
         """

pr_agent/tools/pr_similar_issue.py

@@ -0,0 +1,276 @@
+import copy
+import json
+import logging
+from enum import Enum
+from typing import List, Tuple
+import pinecone
+import openai
+import pandas as pd
+from pydantic import BaseModel, Field
+
+from pr_agent.algo import MAX_TOKENS
+from pr_agent.algo.token_handler import TokenHandler
+from pr_agent.config_loader import get_settings
+from pr_agent.git_providers import get_git_provider
+from pinecone_datasets import Dataset, DatasetMetadata
+
+MODEL = "text-embedding-ada-002"
+
+
+class PRSimilarIssue:
+    def __init__(self, issue_url: str, args: list = None):
+        if get_settings().config.git_provider != "github":
+            raise Exception("Only github is supported for similar issue tool")
+
+        self.cli_mode = get_settings().CONFIG.CLI_MODE
+        self.max_issues_to_scan = get_settings().pr_similar_issue.max_issues_to_scan
+        self.issue_url = issue_url
+        self.git_provider = get_git_provider()()
+        repo_name, issue_number = self.git_provider._parse_issue_url(issue_url.split('=')[-1])
+        self.git_provider.repo = repo_name
+        self.git_provider.repo_obj = self.git_provider.github_client.get_repo(repo_name)
+        self.token_handler = TokenHandler()
+        repo_obj = self.git_provider.repo_obj
+        repo_name_for_index = self.repo_name_for_index = repo_obj.full_name.lower().replace('/', '-').replace('_/', '-')
+        index_name = self.index_name = "codium-ai-pr-agent-issues"
+
+        # assuming pinecone api key and environment are set in secrets file
+        try:
+            api_key = get_settings().pinecone.api_key
+            environment = get_settings().pinecone.environment
+        except Exception:
+            if not self.cli_mode:
+                repo_name, original_issue_number = self.git_provider._parse_issue_url(self.issue_url.split('=')[-1])
+                issue_main = self.git_provider.repo_obj.get_issue(original_issue_number)
+                issue_main.create_comment("Please set pinecone api key and environment in secrets file")
+            raise Exception("Please set pinecone api key and environment in secrets file")
+
+        # check if index exists, and if repo is already indexed
+        run_from_scratch = False
+        upsert = True
+        pinecone.init(api_key=api_key, environment=environment)
+        if not index_name in pinecone.list_indexes():
+            run_from_scratch = True
+            upsert = False
+        else:
+            if get_settings().pr_similar_issue.force_update_dataset:
+                upsert = True
+            else:
+                pinecone_index = pinecone.Index(index_name=index_name)
+                res = pinecone_index.fetch([f"example_issue_{repo_name_for_index}"]).to_dict()
+                if res["vectors"]:
+                    upsert = False
+
+        if run_from_scratch or upsert:  # index the entire repo
+            logging.info('Indexing the entire repo...')
+
+            logging.info('Getting issues...')
+            issues = list(repo_obj.get_issues(state='all'))
+            logging.info('Done')
+            self._update_index_with_issues(issues, repo_name_for_index, upsert=upsert)
+        else:  # update index if needed
+            pinecone_index = pinecone.Index(index_name=index_name)
+            issues_to_update = []
+            issues_paginated_list = repo_obj.get_issues(state='all')
+            counter = 1
+            for issue in issues_paginated_list:
+                if issue.pull_request:
+                    continue
+                issue_str, comments, number = self._process_issue(issue)
+                issue_key = f"issue_{number}"
+                id = issue_key + "." + "issue"
+                res = pinecone_index.fetch([id]).to_dict()
+                is_new_issue = True
+                for vector in res["vectors"].values():
+                    if vector['metadata']['repo'] == repo_name_for_index:
+                        is_new_issue = False
+                        break
+                if is_new_issue:
+                    counter += 1
+                    issues_to_update.append(issue)
+                else:
+                    break
+
+            if issues_to_update:
+                logging.info(f'Updating index with {counter} new issues...')
+                self._update_index_with_issues(issues_to_update, repo_name_for_index, upsert=True)
+            else:
+                logging.info('No new issues to update')
+
+    async def run(self):
+        logging.info('Getting issue...')
+        repo_name, original_issue_number = self.git_provider._parse_issue_url(self.issue_url.split('=')[-1])
+        issue_main = self.git_provider.repo_obj.get_issue(original_issue_number)
+        issue_str, comments, number = self._process_issue(issue_main)
+        openai.api_key = get_settings().openai.key
+        logging.info('Done')
+
+        logging.info('Querying...')
+        res = openai.Embedding.create(input=[issue_str], engine=MODEL)
+        embeds = [record['embedding'] for record in res['data']]
+        pinecone_index = pinecone.Index(index_name=self.index_name)
+        res = pinecone_index.query(embeds[0],
+                                   top_k=5,
+                                   filter={"repo": self.repo_name_for_index},
+                                   include_metadata=True).to_dict()
+        relevant_issues_number_list = []
+        relevant_comment_number_list = []
+        score_list = []
+        for r in res['matches']:
+            issue_number = int(r["id"].split('.')[0].split('_')[-1])
+            if original_issue_number == issue_number:
+                continue
+            if issue_number not in relevant_issues_number_list:
+                relevant_issues_number_list.append(issue_number)
+            if 'comment' in r["id"]:
+                relevant_comment_number_list.append(int(r["id"].split('.')[1].split('_')[-1]))
+            else:
+                relevant_comment_number_list.append(-1)
+            score_list.append(str("{:.2f}".format(r['score'])))
+        logging.info('Done')
+
+        logging.info('Publishing response...')
+        similar_issues_str = "### Similar Issues\n___\n\n"
+        for i, issue_number_similar in enumerate(relevant_issues_number_list):
+            issue = self.git_provider.repo_obj.get_issue(issue_number_similar)
+            title = issue.title
+            url = issue.html_url
+            if relevant_comment_number_list[i] != -1:
+                url = list(issue.get_comments())[relevant_comment_number_list[i]].html_url
+            similar_issues_str += f"{i + 1}. **[{title}]({url})** (score={score_list[i]})\n\n"
+        if get_settings().config.publish_output:
+            response = issue_main.create_comment(similar_issues_str)
+        logging.info(similar_issues_str)
+        logging.info('Done')
+
+    def _process_issue(self, issue):
+        header = issue.title
+        body = issue.body
+        number = issue.number
+        if get_settings().pr_similar_issue.skip_comments:
+            comments = []
+        else:
+            comments = list(issue.get_comments())
+        issue_str = f"Issue Header: \"{header}\"\n\nIssue Body:\n{body}"
+        return issue_str, comments, number
+
+    def _update_index_with_issues(self, issues_list, repo_name_for_index, upsert=False):
+        logging.info('Processing issues...')
+        corpus = Corpus()
+        example_issue_record = Record(
+            id=f"example_issue_{repo_name_for_index}",
+            text="example_issue",
+            metadata=Metadata(repo=repo_name_for_index)
+        )
+        corpus.append(example_issue_record)
+
+        counter = 0
+        for issue in issues_list:
+            if issue.pull_request:
+                continue
+
+            counter += 1
+            if counter % 100 == 0:
+                logging.info(f"Scanned {counter} issues")
+            if counter >= self.max_issues_to_scan:
+                logging.info(f"Scanned {self.max_issues_to_scan} issues, stopping")
+                break
+
+            issue_str, comments, number = self._process_issue(issue)
+            issue_key = f"issue_{number}"
+            username = issue.user.login
+            created_at = str(issue.created_at)
+            if len(issue_str) < 8000 or \
+                    self.token_handler.count_tokens(issue_str) < MAX_TOKENS[MODEL]:  # fast reject first
+                issue_record = Record(
+                    id=issue_key + "." + "issue",
+                    text=issue_str,
+                    metadata=Metadata(repo=repo_name_for_index,
+                                      username=username,
+                                      created_at=created_at,
+                                      level=IssueLevel.ISSUE)
+                )
+                corpus.append(issue_record)
+                if comments:
+                    for j, comment in enumerate(comments):
+                        comment_body = comment.body
+                        num_words_comment = len(comment_body.split())
+                        if num_words_comment < 10 or not isinstance(comment_body, str):
+                            continue
+
+                        if len(comment_body) < 8000 or \
+                                self.token_handler.count_tokens(comment_body) < MAX_TOKENS[MODEL]:
+                            comment_record = Record(
+                                id=issue_key + ".comment_" + str(j + 1),
+                                text=comment_body,
+                                metadata=Metadata(repo=repo_name_for_index,
+                                                  username=username,  # use issue username for all comments
+                                                  created_at=created_at,
+                                                  level=IssueLevel.COMMENT)
+                            )
+                            corpus.append(comment_record)
+        df = pd.DataFrame(corpus.dict()["documents"])
+        logging.info('Done')
+
+        logging.info('Embedding...')
+        openai.api_key = get_settings().openai.key
+        list_to_encode = list(df["text"].values)
+        try:
+            res = openai.Embedding.create(input=list_to_encode, engine=MODEL)
+            embeds = [record['embedding'] for record in res['data']]
+        except:
+            embeds = []
+            logging.error('Failed to embed entire list, embedding one by one...')
+            for i, text in enumerate(list_to_encode):
+                try:
+                    res = openai.Embedding.create(input=[text], engine=MODEL)
+                    embeds.append(res['data'][0]['embedding'])
+                except:
+                    embeds.append([0] * 1536)
+        df["values"] = embeds
+        meta = DatasetMetadata.empty()
+        meta.dense_model.dimension = len(embeds[0])
+        ds = Dataset.from_pandas(df, meta)
+        logging.info('Done')
+
+        api_key = get_settings().pinecone.api_key
+        environment = get_settings().pinecone.environment
+        if not upsert:
+            logging.info('Creating index from scratch...')
+            ds.to_pinecone_index(self.index_name, api_key=api_key, environment=environment)
+        else:
+            logging.info('Upserting index...')
+            namespace = ""
+            batch_size: int = 100
+            concurrency: int = 10
+            pinecone.init(api_key=api_key, environment=environment)
+            ds._upsert_to_index(self.index_name, namespace, batch_size, concurrency)
+        logging.info('Done')
+
+
+class IssueLevel(str, Enum):
+    ISSUE = "issue"
+    COMMENT = "comment"
+
+
+class Metadata(BaseModel):
+    repo: str
+    username: str = Field(default="@codium")
+    created_at: str = Field(default="01-01-1970 00:00:00.00000")
+    level: IssueLevel = Field(default=IssueLevel.ISSUE)
+
+    class Config:
+        use_enum_values = True
+
+
+class Record(BaseModel):
+    id: str
+    text: str
+    metadata: Metadata
+
+
+class Corpus(BaseModel):
+    documents: List[Record] = Field(default=[])
+
+    def append(self, r: Record):
+        self.documents.append(r)

pr_agent/tools/pr_update_changelog.py

@@ -46,7 +46,7 @@ class PRUpdateChangelog:
                                           get_settings().pr_update_changelog_prompt.user)
 
     async def run(self):
-        assert type(self.git_provider) == GithubProvider, "Currently only Github is supported"
+        # assert type(self.git_provider) == GithubProvider, "Currently only Github is supported"
 
         logging.info('Updating the changelog...')
         if get_settings().config.publish_output:

requirements.txt

@@ -7,15 +7,17 @@ Jinja2==3.1.2
 tiktoken==0.4.0
 uvicorn==0.22.0
 python-gitlab==3.15.0
-pytest~=7.4.0
+pytest==7.4.0
-aiohttp~=3.8.4
+aiohttp==3.8.4
 atlassian-python-api==3.39.0
-GitPython~=3.1.32
+GitPython==3.1.32
 PyYAML==6.0
 starlette-context==0.3.6
-litellm~=0.1.504
+litellm~=0.1.574
-boto3~=1.28.25
+boto3==1.28.25
 google-cloud-storage==2.10.0
 ujson==5.8.0
 azure-devops==7.1.0b3
-msrest==0.7.1
+msrest==0.7.1
+pinecone-client
+pinecone-datasets @ git+https://github.com/mrT23/pinecone-datasets.git@main

tests/unittest/test_language_handler.py

@@ -61,7 +61,7 @@ class TestSortFilesByMainLanguages:
             type('', (object,), {'filename': 'file1.py'})(),
             type('', (object,), {'filename': 'file2.java'})()
         ]
-        expected_output = [{'language': 'Other', 'files': []}]
+        expected_output = [{'language': 'Other', 'files': files}]
         assert sort_files_by_main_languages(languages, files) == expected_output
 
     # Tests that function handles empty files list