Merge branch 'main' into feature_azure_devops

pr_agent/git_providers/__init__.py

@@ -1,5 +1,6 @@
 from pr_agent.config_loader import get_settings
 from pr_agent.git_providers.bitbucket_provider import BitbucketProvider
+from pr_agent.git_providers.codecommit_provider import CodeCommitProvider
 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
@@ -10,6 +11,7 @@ _GIT_PROVIDERS = {
     'gitlab': GitLabProvider,
     'bitbucket': BitbucketProvider,
     'azure': AzureDevopsProvider,
+    'codecommit': CodeCommitProvider,
     'local' : LocalGitProvider
 }
 

pr_agent/git_providers/bitbucket_provider.py

@@ -1,3 +1,4 @@
+import json
 import logging
 from typing import Optional, Tuple
 from urllib.parse import urlparse
@@ -5,17 +6,17 @@ from urllib.parse import urlparse
 import requests
 from atlassian.bitbucket import Cloud
 
-from ..algo.pr_processing import clip_tokens
 from ..config_loader import get_settings
-from .git_provider import FilePatchInfo
+from .git_provider import FilePatchInfo, GitProvider
 
 
-class BitbucketProvider:
+class BitbucketProvider(GitProvider):
     def __init__(self, pr_url: Optional[str] = None, incremental: Optional[bool] = False):
         s = requests.Session()
         s.headers['Authorization'] = f'Bearer {get_settings().get("BITBUCKET.BEARER_TOKEN", None)}'
+        s.headers['Content-Type'] = 'application/json'
+        self.headers = s.headers
         self.bitbucket_client = Cloud(session=s)
-
         self.workspace_slug = None
         self.repo_slug = None
         self.repo = None
@@ -25,6 +26,64 @@ class BitbucketProvider:
         self.incremental = incremental
         if pr_url:
             self.set_pr(pr_url)
+        self.bitbucket_comment_api_url = self.pr._BitbucketBase__data['links']['comments']['href']
+
+    def get_repo_settings(self):
+        try:
+            contents = self.repo_obj.get_contents(".pr_agent.toml", ref=self.pr.head.sha).decoded_content
+            return contents
+        except Exception:
+            return ""
+        
+    def publish_code_suggestions(self, code_suggestions: list) -> bool:
+        """
+        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 get_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 get_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.publish_inline_comments(post_parameters_list)
+            return True
+        except Exception as e:
+            if get_settings().config.verbosity_level >= 2:
+                logging.error(f"Failed to publish code suggestion, error: {e}")
+            return False
 
     def is_supported(self, capability: str) -> bool:
         if capability in ['get_issue_comments', 'create_inline_comment', 'publish_inline_comments', 'get_labels']:
@@ -62,14 +121,29 @@ class BitbucketProvider:
         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 publish_inline_comment(self, comment: str, from_line: int, to_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
+        )
+        return response
+                
 
-    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")
+        for comment in comments:
+            self.publish_inline_comment(comment['body'], comment['start_line'], comment['line'], comment['path'])
 
     def get_title(self):
         return self.pr.title
@@ -81,10 +155,7 @@ class BitbucketProvider:
     def get_pr_branch(self):
         return self.pr.source_branch
 
-    def get_pr_description(self):
-        max_tokens = get_settings().get("CONFIG.MAX_DESCRIPTION_TOKENS", None)
-        if max_tokens:
-            return clip_tokens(self.pr.description, max_tokens)
+    def get_pr_description_full(self):
         return self.pr.description
 
     def get_user_id(self):
@@ -104,7 +175,7 @@ class BitbucketProvider:
         parsed_url = urlparse(pr_url)
         
         if 'bitbucket.org' not in parsed_url.netloc:
-            raise ValueError("The provided URL is not a valid GitHub URL")
+            raise ValueError("The provided URL is not a valid Bitbucket URL")
 
         path_parts = parsed_url.path.strip('/').split('/')
         

pr_agent/git_providers/codecommit_client.py

@@ -0,0 +1,203 @@
+import boto3
+import botocore
+
+
+class CodeCommitDifferencesResponse:
+    """
+    CodeCommitDifferencesResponse is the response object returned from our get_differences() function.
+    It maps the JSON response to member variables of this class.
+    """
+
+    def __init__(self, json: dict):
+        before_blob = json.get("beforeBlob", {})
+        after_blob = json.get("afterBlob", {})
+
+        self.before_blob_id = before_blob.get("blobId", "")
+        self.before_blob_path = before_blob.get("path", "")
+        self.after_blob_id = after_blob.get("blobId", "")
+        self.after_blob_path = after_blob.get("path", "")
+        self.change_type = json.get("changeType", "")
+
+
+class CodeCommitPullRequestResponse:
+    """
+    CodeCommitPullRequestResponse is the response object returned from our get_pr() function.
+    It maps the JSON response to member variables of this class.
+    """
+
+    def __init__(self, json: dict):
+        self.title = json.get("title", "")
+        self.description = json.get("description", "")
+
+        self.targets = []
+        for target in json.get("pullRequestTargets", []):
+            self.targets.append(CodeCommitPullRequestResponse.CodeCommitPullRequestTarget(target))
+
+    class CodeCommitPullRequestTarget:
+        """
+        CodeCommitPullRequestTarget is a subclass of CodeCommitPullRequestResponse that
+        holds details about an individual target commit.
+        """
+
+        def __init__(self, json: dict):
+            self.source_commit = json.get("sourceCommit", "")
+            self.source_branch = json.get("sourceReference", "")
+            self.destination_commit = json.get("destinationCommit", "")
+            self.destination_branch = json.get("destinationReference", "")
+
+
+class CodeCommitClient:
+    """
+    CodeCommitClient is a wrapper around the AWS boto3 SDK for the CodeCommit client
+    """
+
+    def __init__(self):
+        self.boto_client = None
+
+    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}")
+
+    def get_differences(self, repo_name: int, destination_commit: str, source_commit: str):
+        """
+        Get the differences between two commits in CodeCommit.
+
+        Parameters:
+        - repo_name: Name of the repository
+        - destination_commit: Commit hash you want to merge into (the "before" hash) (usually on the main or master branch)
+        - source_commit: Commit hash of the code you are adding (the "after" branch)
+
+        Returns:
+        - List of CodeCommitDifferencesResponse objects
+
+        Boto3 Documentation:
+        aws codecommit get-differences
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/codecommit/client/get_differences.html
+        """
+        if self.boto_client is None:
+            self._connect_boto_client()
+
+        # The differences response from AWS is paginated, so we need to iterate through the pages to get all the differences.
+        differences = []
+        try:
+            paginator = self.boto_client.get_paginator("get_differences")
+            for page in paginator.paginate(
+                repositoryName=repo_name,
+                beforeCommitSpecifier=destination_commit,
+                afterCommitSpecifier=source_commit,
+            ):
+                differences.extend(page.get("differences", []))
+        except botocore.exceptions.ClientError as e:
+            raise ValueError(f"Failed to retrieve differences from CodeCommit PR #{self.pr_num}") from e
+
+        output = []
+        for json in differences:
+            output.append(CodeCommitDifferencesResponse(json))
+        return output
+
+    def get_file(self, repo_name: str, file_path: str, sha_hash: str, optional: bool = False):
+        """
+        Retrieve a file from CodeCommit.
+
+        Parameters:
+        - repo_name: Name of the repository
+        - file_path: Path to the file you are retrieving
+        - sha_hash: Commit hash of the file you are retrieving
+
+        Returns:
+        - File contents
+
+        Boto3 Documentation:
+        aws codecommit get_file
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/codecommit/client/get_file.html
+        """
+        if not file_path:
+            return ""
+
+        if self.boto_client is None:
+            self._connect_boto_client()
+
+        try:
+            response = self.boto_client.get_file(repositoryName=repo_name, commitSpecifier=sha_hash, filePath=file_path)
+        except botocore.exceptions.ClientError as e:
+            # if the file does not exist, but is flagged as optional, then return an empty string
+            if optional and e.response["Error"]["Code"] == 'FileDoesNotExistException':
+                return ""
+            raise ValueError(f"CodeCommit cannot retrieve file '{file_path}' from repository '{repo_name}'") from e
+        except Exception as e:
+            raise ValueError(f"CodeCommit cannot retrieve file '{file_path}' from repository '{repo_name}'") from e
+        if "fileContent" not in response:
+            raise ValueError(f"File content is empty for file: {file_path}")
+
+        return response.get("fileContent", "")
+
+    def get_pr(self, pr_number: int):
+        """
+        Get a information about a CodeCommit PR.
+
+        Parameters:
+        - pr_number: The PR number you are requesting
+
+        Returns:
+        - CodeCommitPullRequestResponse object
+
+        Boto3 Documentation:
+        aws codecommit get_pull_request
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/codecommit/client/get_pull_request.html
+        """
+        if self.boto_client is None:
+            self._connect_boto_client()
+
+        try:
+            response = self.boto_client.get_pull_request(pullRequestId=str(pr_number))
+        except botocore.exceptions.ClientError as e:
+            if e.response["Error"]["Code"] == 'PullRequestDoesNotExistException':
+                raise ValueError(f"CodeCommit cannot retrieve PR: PR number does not exist: {pr_number}") from e
+            raise ValueError(f"CodeCommit cannot retrieve PR: {pr_number}: boto client error") from e
+        except Exception as e:
+            raise ValueError(f"CodeCommit cannot retrieve PR: {pr_number}") from e
+
+        if "pullRequest" not in response:
+            raise ValueError("CodeCommit PR number not found: {pr_number}")
+
+        return CodeCommitPullRequestResponse(response.get("pullRequest", {}))
+
+    def publish_comment(self, repo_name: str, pr_number: int, destination_commit: str, source_commit: str, comment: str):
+        """
+        Publish a comment to a pull request
+
+        Parameters:
+        - repo_name: name of the repository
+        - pr_number: number of the pull request
+        - destination_commit: The commit hash you want to merge into (the "before" hash) (usually on the main or master branch)
+        - source_commit: The commit hash of the code you are adding (the "after" branch)
+        - pr_comment: comment
+
+        Returns:
+        - None
+
+        Boto3 Documentation:
+        aws codecommit post_comment_for_pull_request
+        https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/codecommit/client/post_comment_for_pull_request.html
+        """
+        if self.boto_client is None:
+            self._connect_boto_client()
+
+        try:
+            self.boto_client.post_comment_for_pull_request(
+                pullRequestId=str(pr_number),
+                repositoryName=repo_name,
+                beforeCommitId=destination_commit,
+                afterCommitId=source_commit,
+                content=comment,
+            )
+        except botocore.exceptions.ClientError as e:
+            if e.response["Error"]["Code"] == 'RepositoryDoesNotExistException':
+                raise ValueError(f"Repository does not exist: {repo_name}") from e
+            if e.response["Error"]["Code"] == 'PullRequestDoesNotExistException':
+                raise ValueError(f"PR number does not exist: {pr_number}") from e
+            raise ValueError(f"Boto3 client error calling post_comment_for_pull_request") from e
+        except Exception as e:
+            raise ValueError(f"Error calling post_comment_for_pull_request") from e

pr_agent/git_providers/codecommit_provider.py

@@ -0,0 +1,363 @@
+import logging
+import os
+from collections import Counter
+from typing import List, Optional, Tuple
+from urllib.parse import urlparse
+
+from ..algo.language_handler import is_valid_file, language_extension_map
+from ..algo.pr_processing import clip_tokens
+from ..algo.utils import load_large_diff
+from ..config_loader import get_settings
+from .git_provider import EDIT_TYPE, FilePatchInfo, GitProvider, IncrementalPR
+from pr_agent.git_providers.codecommit_client import CodeCommitClient
+
+
+class PullRequestCCMimic:
+    """
+    This class mimics the PullRequest class from the PyGithub library for the CodeCommitProvider.
+    """
+
+    def __init__(self, title: str, diff_files: List[FilePatchInfo]):
+        self.title = title
+        self.diff_files = diff_files
+        self.description = None
+        self.source_commit = None
+        self.source_branch = None  # the branch containing your new code changes
+        self.destination_commit = None
+        self.destination_branch = None  # the branch you are going to merge into
+
+
+class CodeCommitFile:
+    """
+    This class represents a file in a pull request in CodeCommit.
+    """
+
+    def __init__(
+        self,
+        a_path: str,
+        a_blob_id: str,
+        b_path: str,
+        b_blob_id: str,
+        edit_type: EDIT_TYPE,
+    ):
+        self.a_path = a_path
+        self.a_blob_id = a_blob_id
+        self.b_path = b_path
+        self.b_blob_id = b_blob_id
+        self.edit_type: EDIT_TYPE = edit_type
+        self.filename = b_path if b_path else a_path
+
+
+class CodeCommitProvider(GitProvider):
+    """
+    This class implements the GitProvider interface for AWS CodeCommit repositories.
+    """
+
+    def __init__(self, pr_url: Optional[str] = None, incremental: Optional[bool] = False):
+        self.codecommit_client = CodeCommitClient()
+        self.aws_client = None
+        self.repo_name = None
+        self.pr_num = None
+        self.pr = None
+        self.diff_files = None
+        self.git_files = None
+        if pr_url:
+            self.set_pr(pr_url)
+
+    def provider_name(self):
+        return "CodeCommit"
+
+    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.repo_name, self.pr_num = self._parse_pr_url(pr_url)
+        self.pr = self._get_pr()
+
+    def get_files(self) -> list[CodeCommitFile]:
+        # bring files from CodeCommit only once
+        if self.git_files:
+            return self.git_files
+
+        self.git_files = []
+        differences = self.codecommit_client.get_differences(self.repo_name, self.pr.destination_commit, self.pr.source_commit)
+        for item in differences:
+            self.git_files.append(CodeCommitFile(item.before_blob_path,
+                                                 item.before_blob_id,
+                                                 item.after_blob_path,
+                                                 item.after_blob_id,
+                                                 CodeCommitProvider._get_edit_type(item.change_type)))
+        return self.git_files
+
+    def get_diff_files(self) -> list[FilePatchInfo]:
+        """
+        Retrieves the list of files that have been modified, added, deleted, or renamed in a pull request in CodeCommit,
+        along with their content and patch information.
+
+        Returns:
+            diff_files (List[FilePatchInfo]): List of FilePatchInfo objects representing the modified, added, deleted,
+            or renamed files in the merge request.
+        """
+        # bring files from CodeCommit only once
+        if self.diff_files:
+            return self.diff_files
+
+        self.diff_files = []
+
+        files = self.get_files()
+        for diff_item in files:
+            patch_filename = ""
+            if diff_item.a_blob_id is not None:
+                patch_filename = diff_item.a_path
+                original_file_content_str = self.codecommit_client.get_file(
+                    self.repo_name, diff_item.a_path, self.pr.destination_commit)
+                if isinstance(original_file_content_str, (bytes, bytearray)):
+                    original_file_content_str = original_file_content_str.decode("utf-8")
+            else:
+                original_file_content_str = ""
+
+            if diff_item.b_blob_id is not None:
+                patch_filename = diff_item.b_path
+                new_file_content_str = self.codecommit_client.get_file(self.repo_name, diff_item.b_path, self.pr.source_commit)
+                if isinstance(new_file_content_str, (bytes, bytearray)):
+                    new_file_content_str = new_file_content_str.decode("utf-8")
+            else:
+                new_file_content_str = ""
+
+            patch = load_large_diff(patch_filename, new_file_content_str, original_file_content_str)
+
+            # Store the diffs as a list of FilePatchInfo objects
+            info = FilePatchInfo(
+                original_file_content_str,
+                new_file_content_str,
+                patch,
+                diff_item.b_path,
+                edit_type=diff_item.edit_type,
+                old_filename=None
+                if diff_item.a_path == diff_item.b_path
+                else diff_item.a_path,
+            )
+            # Only add valid files to the diff list
+            # "bad extensions" are set in the language_extensions.toml file
+            # a "valid file" is one that is not in the "bad extensions" list
+            if is_valid_file(info.filename):
+                self.diff_files.append(info)
+
+        return self.diff_files
+
+    def publish_description(self, pr_title: str, pr_body: str):
+        return ""  # not implemented yet
+
+    def publish_comment(self, pr_comment: str, is_temporary: bool = False):
+        if is_temporary:
+            logging.info(pr_comment)
+            return
+
+        try:
+            self.codecommit_client.publish_comment(
+                repo_name=self.repo_name,
+                pr_number=str(self.pr_num),
+                destination_commit=self.pr.destination_commit,
+                source_commit=self.pr.source_commit,
+                comment=pr_comment,
+            )
+        except Exception as e:
+            raise ValueError(f"CodeCommit Cannot post comment for PR: {self.pr_num}") from e
+
+    def publish_code_suggestions(self, code_suggestions: list) -> bool:
+        return [""]  # not implemented yet
+
+    def publish_labels(self, labels):
+        return [""]  # not implemented yet
+
+    def get_labels(self):
+        return [""]  # not implemented yet
+
+    def remove_initial_comment(self):
+        return ""  # not implemented yet
+
+    def publish_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        raise NotImplementedError("CodeCommit provider does not support publishing inline comments yet")
+
+    def create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_file: str):
+        raise NotImplementedError("CodeCommit provider does not support creating inline comments yet")
+
+    def publish_inline_comments(self, comments: list[dict]):
+        raise NotImplementedError("CodeCommit provider does not support publishing inline comments yet")
+
+    def get_title(self):
+        return self.pr.get("title", "")
+
+    def get_languages(self):
+        """
+        Returns a dictionary of languages, containing the percentage of each language used in the PR.
+
+        Returns:
+            dict: A dictionary where each key is a language name and the corresponding value is the percentage of that language in the PR.
+        """
+        commit_files = self.get_files()
+        filenames = [ item.filename for item in commit_files ]
+        extensions = CodeCommitProvider._get_file_extensions(filenames)
+
+        # Calculate the percentage of each file extension in the PR
+        percentages = CodeCommitProvider._get_language_percentages(extensions)
+
+        # The global language_extension_map is a dictionary of languages,
+        # where each dictionary item is a BoxList of extensions.
+        # We want a dictionary of extensions,
+        # where each dictionary item is a language name.
+        # We build that language->extension dictionary here in main_extensions_flat.
+        main_extensions_flat = {}
+        for language, extensions in language_extension_map.items():
+            for ext in extensions:
+                main_extensions_flat[ext] = language
+
+        # Map the file extension/languages to percentages
+        languages = {}
+        for ext, pct in percentages.items():
+            languages[main_extensions_flat.get(ext, "")] = pct
+
+        return languages
+
+    def get_pr_branch(self):
+        return self.pr.source_branch
+
+    def get_pr_description_full(self) -> str:
+        return self.pr.description
+
+    def get_user_id(self):
+        return -1  # not implemented yet
+
+    def get_issue_comments(self):
+        raise NotImplementedError("CodeCommit provider does not support issue comments yet")
+
+    def get_repo_settings(self):
+        # a local ".pr_agent.toml" settings file is optional
+        settings_filename = ".pr_agent.toml"
+        return self.codecommit_client.get_file(self.repo_name, settings_filename, self.pr.source_commit, optional=True)
+
+    def add_eyes_reaction(self, issue_comment_id: int) -> Optional[int]:
+        return True
+
+    def remove_reaction(self, issue_comment_id: int, reaction_id: int) -> bool:
+        return True
+
+    @staticmethod
+    def _parse_pr_url(pr_url: str) -> Tuple[str, int]:
+        # Example PR URL:
+        # https://us-east-1.console.aws.amazon.com/codesuite/codecommit/repositories/__MY_REPO__/pull-requests/123456"
+        parsed_url = urlparse(pr_url)
+
+        if "us-east-1.console.aws.amazon.com" not in parsed_url.netloc:
+            raise ValueError(f"The provided URL is not a valid CodeCommit URL: {pr_url}")
+
+        path_parts = parsed_url.path.strip("/").split("/")
+
+        if (
+            len(path_parts) < 6
+            or path_parts[0] != "codesuite"
+            or path_parts[1] != "codecommit"
+            or path_parts[2] != "repositories"
+            or path_parts[4] != "pull-requests"
+        ):
+            raise ValueError(f"The provided URL does not appear to be a CodeCommit PR URL: {pr_url}")
+
+        repo_name = path_parts[3]
+
+        try:
+            pr_number = int(path_parts[5])
+        except ValueError as e:
+            raise ValueError(f"Unable to convert PR number to integer: '{path_parts[5]}'") from e
+
+        return repo_name, pr_number
+
+    def _get_pr(self):
+        response = self.codecommit_client.get_pr(self.pr_num)
+
+        if len(response.targets) == 0:
+            raise ValueError(f"No files found in CodeCommit PR: {self.pr_num}")
+
+        # TODO: implement support for multiple commits in one CodeCommit PR
+        #       for now, we are only using the first commit in the PR
+        if len(response.targets) > 1:
+            logging.warning(
+                "Multiple commits in one PR is not supported for CodeCommit yet. Continuing, using the first commit only..."
+            )
+
+        # Return our object that mimics PullRequest class from the PyGithub library
+        # (This strategy was copied from the LocalGitProvider)
+        mimic = PullRequestCCMimic(response.title, self.diff_files)
+        mimic.description = response.description
+        mimic.source_commit = response.targets[0].source_commit
+        mimic.source_branch = response.targets[0].source_branch
+        mimic.destination_commit = response.targets[0].destination_commit
+        mimic.destination_branch = response.targets[0].destination_branch
+
+        return mimic
+
+    def get_commit_messages(self):
+        return ""  # not implemented yet
+
+    @staticmethod
+    def _get_edit_type(codecommit_change_type):
+        """
+        Convert the CodeCommit change type string to the EDIT_TYPE enum.
+        The CodeCommit change type string is returned from the get_differences SDK method.
+
+        Returns:
+            An EDIT_TYPE enum representing the modified, added, deleted, or renamed file in the PR diff.
+        """
+        t = codecommit_change_type.upper()
+        edit_type = None
+        if t == "A":
+            edit_type = EDIT_TYPE.ADDED
+        elif t == "D":
+            edit_type = EDIT_TYPE.DELETED
+        elif t == "M":
+            edit_type = EDIT_TYPE.MODIFIED
+        elif t == "R":
+            edit_type = EDIT_TYPE.RENAMED
+        return edit_type
+
+    @staticmethod
+    def _get_file_extensions(filenames):
+        """
+        Return a list of file extensions from a list of filenames.
+        The returned extensions will include the dot "." prefix,
+        to accommodate for the dots in the existing language_extension_map settings.
+        Filenames with no extension will return an empty string for the extension.
+        """
+        extensions = []
+        for filename in filenames:
+            filename, ext = os.path.splitext(filename)
+            if ext:
+                extensions.append(ext.lower())
+            else:
+                extensions.append("")
+        return extensions
+
+    @staticmethod
+    def _get_language_percentages(extensions):
+        """
+        Return a dictionary containing the programming language name (as the key),
+        and the percentage that language is used (as the value),
+        given a list of file extensions.
+        """
+        total_files = len(extensions)
+        if total_files == 0:
+            return {}
+
+        # Identify language by file extension and count
+        lang_count = Counter(extensions)
+        # Convert counts to percentages
+        lang_percentage = {
+            lang: round(count / total_files * 100) for lang, count in lang_count.items()
+        }
+        return lang_percentage

pr_agent/git_providers/git_provider.py

@@ -55,7 +55,7 @@ class GitProvider(ABC):
         pass
 
     @abstractmethod
-    def publish_code_suggestions(self, code_suggestions: list):
+    def publish_code_suggestions(self, code_suggestions: list) -> bool:
         pass
 
     @abstractmethod
@@ -83,13 +83,38 @@ class GitProvider(ABC):
         pass
 
     @abstractmethod
-    def get_pr_description(self):
+    def get_pr_description_full(self) -> str:
         pass
 
+    def get_pr_description(self) -> str:
+        from pr_agent.config_loader import get_settings
+        from pr_agent.algo.pr_processing import clip_tokens
+        max_tokens = get_settings().get("CONFIG.MAX_DESCRIPTION_TOKENS", None)
+        description = self.get_pr_description_full()
+        if max_tokens:
+            return clip_tokens(description, max_tokens)
+        return description
+
+    def get_user_description(self) -> str:
+        description = (self.get_pr_description_full() or "").strip()
+        # if the existing description wasn't generated by the pr-agent, just return it as-is
+        if not description.startswith("## PR Type"):
+            return description
+        # if the existing description was generated by the pr-agent, but it doesn't contain the user description,
+        # return nothing (empty string) because it means there is no user description
+        if "## User Description:" not in description:
+            return ""
+        # otherwise, extract the original user description from the existing pr-agent description and return it
+        return description.split("## User Description:", 1)[1].strip()
+
     @abstractmethod
     def get_issue_comments(self):
         pass
 
+    @abstractmethod
+    def get_repo_settings(self):
+        pass
+
     @abstractmethod
     def add_eyes_reaction(self, issue_comment_id: int) -> Optional[int]:
         pass

pr_agent/git_providers/github_provider.py

@@ -166,7 +166,7 @@ class GithubProvider(GitProvider):
     def publish_inline_comments(self, comments: list[dict]):
         self.pr.create_review(commit=self.last_commit_id, comments=comments)
 
-    def publish_code_suggestions(self, code_suggestions: list):
+    def publish_code_suggestions(self, code_suggestions: list) -> bool:
         """
         Publishes code suggestions as comments on the PR.
         """
@@ -233,10 +233,7 @@ class GithubProvider(GitProvider):
     def get_pr_branch(self):
         return self.pr.head.ref
 
-    def get_pr_description(self):
-        max_tokens = get_settings().get("CONFIG.MAX_DESCRIPTION_TOKENS", None)
-        if max_tokens:
-            return clip_tokens(self.pr.body, max_tokens)
+    def get_pr_description_full(self):
         return self.pr.body
 
     def get_user_id(self):

pr_agent/git_providers/gitlab_provider.py

@@ -14,6 +14,9 @@ from .git_provider import EDIT_TYPE, FilePatchInfo, GitProvider
 
 logger = logging.getLogger()
 
+class DiffNotFoundError(Exception):
+    """Raised when the diff for a merge request cannot be found."""
+    pass
 
 class GitLabProvider(GitProvider):
 
@@ -56,7 +59,7 @@ class GitLabProvider(GitProvider):
             self.last_diff = self.mr.diffs.list(get_all=True)[-1]
         except IndexError as e:
             logger.error(f"Could not get diff for merge request {self.id_mr}")
-            raise ValueError(f"Could not get diff for merge request {self.id_mr}") from e
+            raise DiffNotFoundError(f"Could not get diff for merge request {self.id_mr}") from e
 
 
     def _get_pr_file_content(self, file_path: str, branch: str) -> str:
@@ -150,16 +153,20 @@ class GitLabProvider(GitProvider):
     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):
+    def send_inline_comment(self,body: str,edit_type: str,found: bool,relevant_file: str,relevant_line_in_file: int,
+                            source_line_no: int, target_file: str,target_line_no: int) -> None:
         if not found:
             logging.info(f"Could not find position for {relevant_file} {relevant_line_in_file}")
         else:
-            d = self.last_diff
+            # in order to have exact sha's we have to find correct diff for this change
+            diff = self.get_relevant_diff(relevant_file, relevant_line_in_file)
+            if diff is None:
+                logger.error(f"Could not get diff for merge request {self.id_mr}")
+                raise DiffNotFoundError(f"Could not get diff for merge request {self.id_mr}")
             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}
+                       'base_sha': diff.base_commit_sha, 'start_sha': diff.start_commit_sha, 'head_sha': diff.head_commit_sha}
             if edit_type == 'deletion':
                 pos_obj['old_line'] = source_line_no - 1
             elif edit_type == 'addition':
@@ -171,7 +178,24 @@ class GitLabProvider(GitProvider):
             self.mr.discussions.create({'body': body,
                                         'position': pos_obj})
 
-    def publish_code_suggestions(self, code_suggestions: list):
+    def get_relevant_diff(self, relevant_file: str, relevant_line_in_file: int) -> Optional[dict]:
+        changes = self.mr.changes()  # Retrieve the changes for the merge request once
+        if not changes:
+            logging.error('No changes found for the merge request.')
+            return None
+        all_diffs = self.mr.diffs.list(get_all=True)
+        if not all_diffs:
+            logging.error('No diffs found for the merge request.')
+            return None
+        for diff in all_diffs:
+            for change in changes['changes']:
+                if change['new_path'] == relevant_file and relevant_line_in_file in change['diff']:
+                    return diff
+            logging.debug(
+                f'No relevant diff found for {relevant_file} {relevant_line_in_file}. Falling back to last diff.')
+        return self.last_diff  # fallback to last_diff if no relevant diff is found
+
+    def publish_code_suggestions(self, code_suggestions: list) -> bool:
         for suggestion in code_suggestions:
             try:
                 body = suggestion['body']
@@ -275,10 +299,7 @@ class GitLabProvider(GitProvider):
     def get_pr_branch(self):
         return self.mr.source_branch
 
-    def get_pr_description(self):
-        max_tokens = get_settings().get("CONFIG.MAX_DESCRIPTION_TOKENS", None)
-        if max_tokens:
-            return clip_tokens(self.mr.description, max_tokens)
+    def get_pr_description_full(self):
         return self.mr.description
 
     def get_issue_comments(self):

pr_agent/git_providers/local_git_provider.py

@@ -130,7 +130,7 @@ class LocalGitProvider(GitProvider):
                                 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):
+    def publish_code_suggestions(self, code_suggestions: list) -> bool:
         raise NotImplementedError('Publishing code suggestions is not implemented for the local git provider')
 
     def publish_labels(self, labels):
@@ -158,7 +158,7 @@ class LocalGitProvider(GitProvider):
     def get_user_id(self):
         return -1  # Not used anywhere for the local provider, but required by the interface
 
-    def get_pr_description(self):
+    def get_pr_description_full(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])