Changing git commit message after push (given that no one pulled from remote)

I have made a git commit and subsequent push. I would like to change the commit message. If I understand correctly, this is not advisable because someone might have pulled from the remote repository before I make such changes. What if I know that no one has pulled?

Is there a way to do this?

11 Answers
11

If it is the most recent commit, you can simply do this:

git commit --amend


This brings up the editor with the last commit message and lets you edit the message. (You can use -m if you want to wipe out the old message and use a new one.)

-m

And then when you push, do this:

git push --force-with-lease <repository> <branch>


Or you can use "+":

git push <repository> +<branch>


Or you can use --force:

--force

git push --force <repository> <branch>


Be careful when using these commands.

If someone else pushed changes to the same branch, you probably want to avoid destroying those changes. The --force-with-lease option is the safest, because it will abort if there are any upstream changes (

--force-with-lease

If you don't specify the branch explicitly, Git will use the default push settings. If your default push setting is "matching", then you may destroy changes on several branches at the same time.

Anyone who already pulled will now get an error message, and they will need to update (assuming they aren't making any changes themselves) by doing something like this:

git fetch origin
git reset --hard origin/master # Loses local commits


Be careful when using reset --hard. If you have changes to the branch, those changes will be destroyed.

reset --hard

The destroyed data is really just the old commit message, but --force doesn't know that, and will happily delete other data too. So think of --force as "I want to destroy data, and I know for sure what data is being destroyed." But when the destroyed data is committed, you can often recover old commits from the reflog—the data is actually orphaned instead of destroyed (although orphaned commits are periodically deleted).

--force

--force

If you don't think you're destroying data, then stay away from --force... bad things might happen.

--force

This is why --force-with-lease is somewhat safer.

--force-with-lease

-m

git push --force

Just say :

git commit --amend -m "New commit message"


and then

git push --force


git push origin <BRANCH-NAME>

git push --force

git push --force

Might be late to the party, here is an answer I do not see here.

Step1: git rebase -i HEAD~n to do interactive rebase for the last n commits affected.

git rebase -i HEAD~n

n

git will pop up an editor to handle those commits, notice this command: # r, reword = use commit, but edit the commit message, that is exactly we need.

# r, reword = use commit, but edit the commit message

Step2: change pick to r for those commits that you want to update the msg.
Save and close the editor.

pick

r

Step3: in the following commit files, update the commit msg as you like

Step4: after all commits msgs are updated. you might want to do git push -f to update the remote.

git push -f

git rebase -i HEAD~3

git rebase --continue

vi

nano

GIT_EDITOR=nano git rebase -i HEAD~n

Use these two step in console :

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


and then

git push -f


Done :)

It should be noted that if you use push --force with mutiple refs, they will ALL be modified as a result. Make sure to pay attention to where your git repo is configured to push to. Fortunately there is a way to safeguard the process slightly, by specifying a single branch to update. Read from the git man pages:

push --force

Note that --force applies to all the refs that are pushed, hence using
it with push.default set to matching or with multiple push
destinations configured with remote.*.push may overwrite refs other
than the current branch (including local refs that are strictly behind
their remote counterpart). To force a push to only one branch, use a +
in front of the refspec to push (e.g git push origin +master to force
a push to the master branch).

If you want to modify an older commit, not the last one, you will need to use rebase command as explained in here,Github help page , on the Amending the message of older or multiple commit messages section

rebase

Command 1.

git commit --amend -m "New and correct message"


Then,

Command 2.

git push origin --force


git commit --amend


then edit then change the message in the current window. After that do

git push --force-with-lease


This works for me pretty fine,

git checkout origin/branchname

if you're already in branch then it's better to do pull or rebase

git pull


or

git -c core.quotepath=false fetch origin --progress --prune


Later you can simply use

git commit --amend -m "Your message here"


or if you like to open text-editor then use

git commit --amend


I will prefer using text-editor if you have many comments. You can set your preferred text-editor with command

git config --global core.editor your_preffered_editor_here


Anyway, when your are done changing the commit message, save it and exit

and then run

git push --force


And you're done

Another option is to create an additional "errata commit" (and push) which references the commit object that contains the error -- the new errata commit also provides the correction. An errata commit is a commit with no substantive code changes but an important commit message -- for example, add one space character to your readme file and commit that change with the important commit message, or use the git option --allow-empty. It's certainly easier and safer than rebasing, it doesn't modify true history, and it keeps the branch tree clean (using amend is also a good choice if you are correcting the most recent commit, but an errata commit may be a good choice for older commits). This type of thing so rarely happens that simply documenting the mistake is good enough. In the future, if you need to search through a git log for a feature keyword, the original (erroneous) commit may not appear because the wrong keyword was used in that original commit (the original typo) -- however, the keyword will appear in the errata commit which will then point you to the original commit that had the typo. Here's an example:

--allow-empty

amend

git commit -m “fixed feature A”

—allow-empty

git commit -m “Errata commit for previous commit e3ab7312... original message should have been ‘fixed feature *B*’

additional information for same problem if you are using bitbucket pipeline

edit your message

git commit --amend


push to the sever

git push --force <repository> <branch>


then add --force to your push command on the pipeline

git ftp push --force


This will delete your previous commit(s) and push your current one.

remove the --force after first push

i tried it on bitbucket pipeline and its working fine

Thanks for contributing an answer to Stack Overflow!

But avoid …

To learn more, see our tips on writing great answers.

Some of your past answers have not been well-received, and you're in danger of being blocked from answering.

Please pay close attention to the following guidance:

But avoid …

To learn more, see our tips on writing great answers.

Required, but never shown

Required, but never shown

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.