How do I edit an incorrect commit message in Git?

git commit --amend -m "your new message"

If the commit you want to fix isn’t the most recent one:

1. git rebase --interactive $parent_of_flawed_commit

   If you want to fix several flawed commits, pass the parent of the oldest one of them.

2. An editor will come up, with a list of all commits since the one you gave.

   1. Change pick to reword (or on old versions of Git, to edit) in front of any commits you want to fix.
   2. Once you save, Git will replay the listed commits.
      
      

3. For each commit you want to reword, Git will drop you back into your editor. For each commit you want to edit, Git drops you into the shell. If you’re in the shell:

   1. Change the commit in any way you like.
   2. git commit --amend
   3. git rebase --continue

Most of this sequence will be explained to you by the output of the various commands as you go. It’s very easy, you don’t need to memorise it – just remember that git rebase --interactive lets you correct commits no matter how long ago they were.

Note that you will not want to change commits that you have already pushed. Or maybe you do, but in that case you will have to take great care to communicate with everyone who may have pulled your commits and done work on top of them. How do I recover/resynchronise after someone pushes a rebase or a reset to a published branch?

To amend the previous commit, make the changes you want and stage those changes, and then run

git commit --amend

This will open a file in your text editor representing your new commit message. It starts out populated with the text from your old commit message. Change the commit message as you want, then save the file and quit your editor to finish.

To amend the previous commit and keep the same log message, run

git commit --amend -C HEAD

To fix the previous commit by removing it entirely, run

git reset --hard HEAD^

If you want to edit more than one commit message, run

git rebase -i HEAD~commit_count

(Replace commit_count with number of commits that you want to edit.) This command launches your editor. Mark the first commit (the one that you want to change) as “edit” instead of “pick”, then save and exit your editor. Make the change you want to commit and then run

git commit --amend
git rebase --continue

A plain

git commit --amend

will run your editor and load the previous commit message. All you have to do is edit it and save.

As already mentioned, git commit --amend is the way to overwrite the last commit. One note: if you would like to also overwrite the files, the command would be

git commit -a --amend -m "My new commit message"

You also can use git filter-branch for that.

git filter-branch -f --msg-filter "sed 's/errror/error/'" $flawed_commit..HEAD

It's not as easy as a trivial "git commit --amend", but it's especially useful, if you already have some merges after your erroneous commit message.

Note that this will try to rewrite EVERY commit between HEAD and the flawed commit, so you should choose your msg-filter command very wise ;-)

I prefer this way.

git commit --amend -c <commit ID>

Otherwise, there will be a new commit with a new commit ID

1. If you only want to modify your last commit message, then do:

   $ git commit --amend That will drop you into your text exitor and let you change the last commit message.

2. If you want to change the last 3 commit messages, or any of the commit messages up to that point, supply 'HEAD~3' to the git rebase -i command.

   $ git rebase -i HEAD~3

You can use Git rebasing. For example, if you want to modify back to commit bbc643cd, run

$ git rebase bbc643cd^ --interactive

In the default editor, modify 'pick' to 'edit' in the line whose commit you want to modify. Make your changes and then stage them with

$ git add <filepattern>

Now you can use

$ git commit --amend

to modify the commit, and after that

$ git rebase --continue

to return back to the previous head commit.

If you have to change an old commit message over multiple branches (i.e., the commit with the erroneous message is present in multiple branches) you might want to use

git filter-branch -f --msg-filter 'sed "s/<old message>/<new message>/g"' -- --all

Git will create a temporary directory for rewriting and additionally backup old references in refs/original/.

-f will enforce the execution of the operation. This is necessary if the the temporary directory is already present or if there are already references stored under refs/original. If that is not the case, you can drop this flag.

-- separates filter-branch options from revision options

--all will make sure, that all branches and tags are rewritten.

Due to the backup of your old references, you can easily go back to the state before executing the command.

Say, you want to recover your master and access it in branch old_master:

git checkout -b old_master refs/original/refs/heads/master

Use

git commit --amend

To understand it in detail, an excellent post is 4. Rewriting Git History. It also talks about when not to use git commit --amend.

if you are using the Git GUI tool there is a button named amend last commit. Click on that button and then it will display your last commit files and message. Just edit that message and you can commit it with new commit message.

Or use this command from a console/ terminal

git commit -a --amend -m "My new commit message"

If you are using the Git GUI, you can amend the last commit which hasn't been pushed with:

Commit/Amend Last Commit

You have a couple of options here. You can do git commit --amend as long as it's your last commit. Otherwise if it's not your last commit you can do an interactive rebase. git rebase -i [branched_from] [hash before commit]. Then inside the interactive rebase you simply add edit to that commit. When it comes up do a git commit --amend and modify the commit message. If you want to roll back before that commit point you could also use git reflog and just delete that commit. Then you just do a git commit again.

You can use Git rebasing. For example, if you want to modify back to commit bbc643cd, run

$ git rebase bbc643cd^ --interactive

In the default editor, modify 'pick' to 'edit' in the line whose commit you want to modify. Make your changes and then stage them with

$ git add <filepattern>

Now you can use

$ git commit --amend

to modify the commit, and after that

$ git rebase --continue

to return back to the previous head commit.

I use git gui as much as I can, and that gives you the option to amend the last commit:

Also, git rebase -i origin/masteris a nice mantra that will always present you with the commits you have done on top of master, and give you the option to amend, delete, reorder or squash. No need to get hold of that hash first.

Wow, so there are a lot of ways to do this.

Yet another way to do this is to delete the last commit, but keep its changes so that you won't lose your work. You can then do another commit with the corrected message. This would look something like this:

git reset --soft HEAD~1
git commit -m 'New and corrected commit message'

I always do this if I forget to add a file or do a change.

Remember to specify --soft instead of --hard, otherwise you lose that commit entirely.

If you just want to edit the latest commit use:

git commit --amend

or

git commit --amend -m 'one line message'

But if you want to edit several commits in a row you should use rebasing instead:

git rebase -i <hash of one commit before the wrong commit>

In a file like the one above write edit/e or one of the other option and hit save and exit.

Now you'll be at the first wrong commit. Make changes in the files, and they'll be automatically staged for you. Type

git commit --amend

save and exit that and type

git rebase --continue 

to move to next selection until finished with all your selections.

Note that these things change all your SHA hashes after that particular commit.

I have added the alias of reci, recm for recommit (amend) it, now I can do it with git recm or git recm -m .

$ vim ~/.gitconfig

[alias]

    ......
    cm = commit
    reci = commit --amend
    recm = commit --amend
    ......

Update your last wrong commit message with new commit message in one line:

$ git commit --amend -m "your new commit message"

OR, Try git reset like below:

# You can reset your head to n number of commit
$ git reset --soft HEAD^

# it will reset you last commit. Now, you can re-commit it with new commit message.

git reset helps you to break one commit to multiple commits too

# reset your head. I am resetting to last commits:
$ git reset --soft HEAD^ (you can reset multiple commit by doing HEAD~2(no. of commits)

# Now, reset your head for splitting it to multiple commits
$ git reset HEAD

# add and commit your files seperately to make multiple commits: e.g
$ git add app/
$ git commit -m "add all files in app directory"

$ git add config/
$ git commit -m "add all files in config directory"

Here you have successfully broke your last commit into two commits.

To change a commit message of the most recent (unpushed) commit, you can simply use

git commit --amend -m 'new message'

To change messages of (unpushed) commits further in the past:

git rebase -i [COMMIT BEFORE THE FIRST YOU WANT TO EDIT]

git commit --amend -m "your new message that you want to show"

You can also do in this way :

git commit --amend

This will run your editor and load the previous commit message. You have to edit it and save.

I hope this will surely help you! :)