If you go to Changelist -> Log, and there select the commit, you've got a change detail in the right panel. There you can select all and click a button (or right click -> revert selected changes).

If it's a single commit that you want to place back into staging, then you can do the following command:

git reset --soft HEAD^

You can replicate that in IntelliJ through these steps:

• VCS > Git > Reset HEAD
• Change reset type to "Soft"
• Change commit to HEAD^

You can reset the head on your checked out branch to any hash you'd like in your history. It won't make changes to the files in your workspace without the -hard flag, so just do a reset to whatever commit you'd like, without passing it -hard.

This, of course, ignores whatever "Intellij" is, but you asked a question in "r/git", and that's how what you asked is addressed with Git.

In the latest version, you simply go to version control, right click the commit and select Undo Commit. This will put the changes back into a change list (so you can edit if needed) and remove the commit. You can remove the change list / revert the changes if you want them gone completely.

Using the Reset HEAD option should work too, just make sure to select a correct target and set an appropriate reset type (Mixed if you want to keep the changes, Hard if you want the changes gone too). To make it easier to find the target, you can find a Reset Current Branch to Here option when right clicking a commit in version control.

In your example, you have merged unwanted changes from development to autoapproval_hierarchy_ui

Problem:
I made a test environment where I merged 4 commits from dev to remote main My current Git Model. Now I want to revert dev changes from remote main!

Solution:
Go to your IntelliJ Idea:

1. Understand where dev branch collides with main. From my Git Model Examle Git Model example it is where I have a commit: Merge pull request #1 from dev
2. Make a left-click on that collision (now in the right bottom corner appeared a window)
3. Hover over the root directory option and make right-click Image of this step
4. Pick option: Revert Selected Changes
5. Pop-up window can appear Example of a pop-up window. Select OK
6. Now you have changes that will return main to the status before dev merge. Before dev merge.
7. Now push this changes to remote main with the next commands:

git add .
git commit -m "YOUR COMMIT MESSAGE"
git push origin main

YOUR COMMIT MESSAGE - For example: Reverted last merge

Now you can see that main branch got rid of unwanted changes from dev branch: Final result

Committing and pushing are two separate operations. Since you created a commit using IntelliJ it means you have one commit. Now when you push, git tries to push all your commits(in this case 1 commit) to remote. Since you haven't pushed you are just left with the Intellij created commit. so removing the commit is just an other operation.

git reset HEAD~1 

should leave your original changes. For more info on undoing things check 12th slide in this presentation on Git http://vineelkumarreddy.com/index.php/2015/08/01/git-talk/

Hope this helps you :)

You can revert individual commits with:

git revert <commit_hash>

This will create a new commit which reverts the changes of the commit you specified. Note that it only reverts that specific commit, and not commits that come after that. If you want to revert a range of commits, you can do it like this:

git revert <oldest_commit_hash>..<latest_commit_hash>

It reverts all the commits after <oldest_commit_hash> up to and including <latest_commit_hash>. Some versions of git also revert the <oldest_commit_hash> itself, so double check if that commit gets reverted or not. You can always drop the latest revert commit (which reverts the oldest commit) with g reset --hard HEAD~.

To find out the hash of the commit(s) you can use git log.

Look at the git-revert man page for more information about the git revert command. Also, look at this answer for more information about reverting commits.

Extra note for re-applying reverted commits:

Usually you revert commits because you discovered the commits that you pushed turn out to have an issue. Then you first want to restore the repo to a stable state, before you continue to fix the issue. So then you would first do the git revert, as described before. Then push those revert commits, so the remote is stable. After that you would want to re-apply the reverted commits locally, so your local repo's files are back to the state before the revert. Then you can fix the issue.

To re-apply the reverted commits, you have to revert the revert commits. So what you would do, is to again execute the git revert command, but then with the range of commits of the revert commits. So your new revert commits will revert the previous revert commits. Then your files are back to the state before the first revert. Then you can fix the issue, create a new commit with the fix, and then push all the new commits.