Removing multiple files from a Git repo that have already been deleted from disk

Question

I have a Git repo that I have deleted four files from using rm (not git rm), and my Git status looks like this:

#    deleted:    file1.txt
#    deleted:    file2.txt
#    deleted:    file3.txt
#    deleted:    file4.txt

How do I remove these files from Git without having to manually go through and add each file like this:

git rm file1 file2 file3 file4

Ideally, I'm looking for something that works in the same way that git add . does, if that's possible.

Elayneelazaro

related: #1857154 – Samadhi

@seth, it's not always convenient to use git rm, the removal could have been from a separate tool, IDE or file manager. Visual Studio for one can be a pain when removing/renaming files. – Hobbema

Ugh, asking why someone doesn't use git rm is a bit like asking why they don't use git vim or git cd. It's a stupid thing to have to do, and git should have a built-in command or alias to remove deleted files from staging, and you shouldn't have to look it up on SO or read man pages on your lunch break. – Boogeyman

Varinder's answer is not a good way. Consider git add -u as Cody suggested and which is also the answer to this question: #1403276 – Carcassonne

Possible duplicate of How to add and commit removals made with "rm" instead of "git rm"? – Mukund

@Carcassonne git add -u will add all modified files that are being tracked. It make work because of circumstances (everything else has been committed), but if you're hoping it will just synchronize your deletes, then you may have some work finding the proper commit for some edits later. – Liquid

Answer 1

For Git 1.x

$ git add -u

This tells git to automatically stage tracked files -- including deleting the previously tracked files.

For Git 2.0

To stage your whole working tree:

$ git add -u :/

To stage just the current path:

$ git add -u .

Islean

Note that this will add all changed, tracked files--deleted and updated. – Chaunceychaunt

@beanland, you need only provide the path to the specific file you want to modify if you don't want it to get them all. e.g. git add -u [path] – Yul

also git add -u folder/ to run this operation in a folder – Cismontane

Huh, this is not working for me on git 1.8.1.msysgit.1 on windows 7 32-bit. Maybe I need to way git add -u *? – Polymerize

Please see @Hotschke's git rm $(git ls-files --deleted) comment on Saeb's answer. – Kilah

This command no longer works for git 2.0. According to the error message I got when I tried it, the proper command is git add --update :/ – Concertmaster

I also like using git clean -f -d before issuing git add -u when I don't have any new files to start tracking. – Granophyre

FYI: this answer merged from #1403276 – Insulin

It might be the question people were asking when they arrived at this page, and it might be what the OP actually meant to ask, but it doesn't answer the exact question asked. – Tow

FYI: some of the deleted files may show up as renames using this technique if, for example, the same file now exists (added) in a different (added) directory. – Aixenprovence

Adding all tracked files that have been updated is probably not what you want. I hope you don't actually need to revert to something you accidentally committed under this. It might be hard to track down under a comment of something like "removing deleted files from git". – Liquid

Answer 2

git ls-files --deleted -z | xargs -0 git rm 

might be what you are looking for.. it works for me..

Buckden

for windows try to add the following alias in your config without the quotes as stated above by Evan Moran 'remove = !git ls-files --deleted -z | xargs -0 git rm' – Gonocyte

That is actually the correct answer since -u also adds modified tracked files to the index. – Matson

be wary of files with spaces in their name – Chivy

@Chivy - how do you handle files with spaces in their name? – Calomel

@DaveEveritt git ls-files --deleted -z | xargs -0 git rm – Euchromatin

@Chivy please don't radically change answers. This one is three-year-old. The change should not have been approved. – Shayneshays

'git ls-files --deleted | sed 's/(.*)/"\1"/'| xargs git rm' for the situation when the file path has space – Ageold

git add -u as Cody suggested is a much simpler and safer way, no risk of accidentally deleting files. – Carcassonne

I think I have a problem using the solution mentioned above because i have so many deleted files(discarded sub-project), it literally tells me -bash: /usr/bin/git: Argument list too long. Answer should be @MaxNanasy 's/ – Sociopath

Seems to be working on PowerShell (not git shell or anything, just generic PowerShell with git.exe installed) and it worked! – Irresoluble

Won't work with files containing spaces in their name. Use git add -u instead shorter and safer. – Adur

Would you please elaborate on what this does? – Roadbed

git ls-files --deleted yields all files with status deleted. For each deleted file, git does a git rm. – Davie

Downvoting this as it is the wrong answer even if it might work for some files. use "git add -u" below. That's what it's for. – Contredanse

such a simple action, and this difficult enough solution.. git-way – Kieffer

Windows users should get MSYS2 or "Git for Windows" so they can run a normal bash environment (like the rest of the world) and use this command. – Scoop

Downvote because the solution is dangerous and instable. A pity it's accepted by the OP. – Decimeter

git add -u will add files that have either been updated or deleted. It could cause problems for people trying to sort out their changes, so it shouldn't be the proper answer. Also, I'm glad the update stood. Using <cmd1> | xargs <cmd2> instead of <cmd2> $(<cmd1>) is not a radical change @Popnoodles, and it works better. Remember, in order for stackoverflow to be useful, people need to easily find good answers. Even at 8.5 years old, this answer was my first solid search result on Google, so don't act like the information went bad. – Liquid

Awesome! You may want to add -r to xargs, so it won't fail if there happens to not be any deleted file. – Therein

Answer 3

You can use

git add -u

To add the deleted files to the staging area, then commit them

git commit -m "Deleted files manually"

Addison

Please note Google user: It adds the modified tracked files to the staging area as well. – Nikitanikki

Run this command only if you had just removed the files and want to stage them immediately. – Incept

i am not able to remove file from bitbucket repo] – Mohammedanism

Answer 4

If you simply run:

git add -u

git will update its index to know that the files that you've deleted should actually be part of the next commit. Then you can run "git commit" to check in that change.

Or, if you run:

git commit -a

It will automatically take these changes (and any others) and commit them.

Update: If you only want to add deleted files, try:

git ls-files --deleted -z | xargs -0 git rm
git commit

Myriad

Right, git commit -a will do what I want, except in some cases I have files that I don't want to commit, so i want to prepare the commit manually. – Garlaand

commit -a essentially does an "add -u" first; it will update the index with any changes to known files (be they deletions or simple changes). You can of course be more specific and add/rm only the files you want. git.or.cz/gitwiki/… may be helpful. – Myriad

The commandset beneath the "Update: .." worked like a charm. Thanks! – Galsworthy

Thank you so much for 'git ls-files --deleted | xargs git rm' ! – Indecorous

"git ls-files --deleted | xargs git rm" is the correct answer! Thanks! – Brittle

"git ls-files" is incorrect: this outputs filenames with literal spaces, that breaks the next part. – Kabuki

@Kabuki I've updated the syntax with flags that will parse correctly in xargs. – Myriad

git commit -a -u -m 'commit message' will stage all changes including deletions, and commit all in one line – Dirt

FYI: this answer merged from #1403276 – Insulin

Answer 5

You're probably looking for -A:

git add -A

this is similar to git add -u, but also adds new files. This is roughly the equivalent of hg's addremove command (although the move detection is automatic).

Elite

On a quick side note, using -u limits the add to tracked files and -a will include untracked files as well. Just thought I would point out the difference. – Filia

At this stage you might as well add all via the commit -a flag. – Hillell

Answer 6

To stage only the deleted files:

for x in $(git status | grep deleted | awk '{print $2}'); do git rm $x; done

Or (the xargs way):

git status | awk '/deleted/ {print $2}' | xargs git rm

You can alias your preferred command set for convenient later use.

Farris

@Saeb Understand about the queue, but xargs is about 15 minutes to master. – Gallium

git status | awk '/deleted/ {print $3}' | xargs git rm would be a shorter way to do that. grep | awk... Just Say No. – Lycia

git rm $(git ls-files --deleted) isn't this more convenient ( copied from this). – Nee

xargs or the above $() substitution if you know the list isn't huge. If the list is huge: git ls-files --deleted | while read f; do git rm $f; done – Proterozoic

bit more elegant:git status | awk '/deleted/{print "git rm " $3}' | sh – Kelp

Preview version of Saeb's answer for the nervous: for x in ``git status | grep deleted | awk '{print $3}'``; do echo $x; done (replace double backticks with single ones); SO's markup escaping doesn't seem to work. – Volleyball

@Proterozoic xargs is probably more efficient than a while loop for a huge list, since it passes more than one argument each time it executes git rm. To limit the number of arguments passed to git rm each time it is executed, use the -n option: git ls-files --deleted | xargs -n 15 git rm – Psychopharmacology

@Psychopharmacology learned something new: xargs -n is very winning. Thanks! – Proterozoic

FYI: this answer merged from #1403276 – Insulin

Answer 7

git rm test.txt

Before or after you deleted the actual file.

Impoverished

While it'll work, I often find myself deleting a ton of files through just rm and regretting it later. – Islean

Why is this worse than doing git add -u? It seems like it'd be safer to add the specific files that were deleted to the commit, rather than adding ALL changes. – Gunpaper

actually this should be the best answer according to the question's last line "I just want a command that deletes all files from git that are also deleted from the disk." – Azores

@Azores no, because it doesnt do that at all. This deletes a single file; the OP SPECIFICALLY requested "all" deleted files. – Kabuki

@Kabuki You are right. This single command cannot delete "all" deleted files. You have to run this command multiple times for multiple files. But you can use wild-card to delete multiple files. – Azores

@Azores no, that's the point - in almost all cases you CANNOT simply use a wildcard (there is no wildcard that will match). This is why there's the main answer is so much more complicated. – Kabuki

@Kabuki The main thing is I use "git rm filename" or "git rm folder/*" normally in my project. And normally it is enough for me. – Azores

I can't believe this response got so many upvotes. All it did was give the basic command from the manual to remove one file at a time. The question asked for something "Similar to git add . which would add all new and modified files to the stage." This does not answer the question at all. – Superb

FYI: this answer merged from #1403276 – Insulin

this does not help when there are spaces in filenames. – Keratin

WARNING: THIS DELETES THE FILES ON DISK TOO. I just accidentally deleted tons of files... – Gil

Answer 8

By using git-add with '--all' or '--update' options you may get more than you wanted. New and/or modified files will also be added to the index. I have a bash alias setup for when I want to remove deleted files from git without touching other files:

alias grma='git ls-files --deleted -z | xargs -0 git rm'

All files that have been removed from the file system are added to the index as deleted.

Madcap

Answer 9

Not that it really matters, but I disagree with the chose answer:

git add -u 

... will remove files from the index if the corresponding files in the working tree have been removed, but it will also stage the modified new contents of tracked files.

git rm $(git ls-files --deleted)

... on the other hand will only rm the deleted files that were tracked.

So the latter in my view is the better option.

Wenger

Answer 10

If those are the only changes, you can simply do

git commit -a

to commit all changes. That will include deleted files.

Earing

Not sure why I got down-voted; git does a good job of identifying files that have been deleted, even if you've not explicitly told it by using git rm. – Earing

You got down-voted because "-a" is not an acceptable switch, it's "-A". Editing your answer. – Tong

No, "-a" is an acceptable switch, because the command is commit. "-A" is a switch to add but not commit. I see your suggested edit has already been rejected. – Earing

In case the only thing you're committing is the deleted file, add the switch --allow-empty – Drusilladrusus

err, actually --allow-empty is only needed if you did git rm --cached – Drusilladrusus

Answer 11

git ls-files --deleted | xargs git rm 

is the best option to add only deleted files.

Here is some other options.

git add .  => Add all (tracked and modified)/new files in the working tree.

git add -u => Add all modified/removed files which are tracked.

git add -A => Add all (tracked and modified)/(tracked and removed)/new files in the working tree.

git commit -a -m "commit message" - Add and commit modified/removed files which are tracked.

Serbocroatian

Answer 12

git add -u

-u --update Only match against already tracked files in the index rather than the working tree. That means that it will never stage new files, but that it will stage modified new contents of tracked files and that it will remove files from the index if the corresponding files in the working tree have been removed.

If no is given, default to "."; in other words, update all tracked files in the current directory and its subdirectories.

Wilhoit

The top-voted answer already says to use git add -u. Where does all of the other stuff in your answer come from, the documentation? You should link to the documentation and blockquote it if it does. – Jorie

Answer 13

That simple solution works fine for me:

git rm $(git ls-files --deleted)

District

I think you should always use git shell on you current working directory – District

This is nice and simple but doesn't work with recursive folders. – Symmetrical

@BehnazChangizi I think it does, #1054544 – District

@PvdL not accepted spaces in the path is os-specefic problem – District

Answer 14

git rm $(git ls-files -d)

Removes all files listed by the git ls-files command (-d show only deleted files). Doesn't work for files with spaces in the filename or path, but easy to remember

Nessa

Answer 15

If you want to add it to your .gitconfig do this:

[alias]
  rma = !git ls-files --deleted -z | xargs -0 git rm

Then all you have to do is run:

git rma

Septuplicate

and from cmd line git config --global alias.rmd '!git ls-files --deleted -z | xargs -0 git rm' – Ewall

Answer 16

git ls-files --deleted -z | xargs -0 git rm --cached

This will remove all deleted files that were previous tracked by git, as well as handle the case where your filenames have spaces in them.

Depending on your POSIX variant, you may need to use xargs -0 -r: this will cause xargs to gracefully exit when piped null content.

EDIT: --cached and --deleted flags are used in tandem to safeguard against accidentally deleting files that have not already been deleted.

Citystate

Answer 17

As mentioned

git add -u

stages the removed files for deletion, BUT ALSO modified files for update.

To unstage the modified files you can do

git reset HEAD <path>

if you like to keep your commits organized and clean.
NOTE: This could also unstage the deleted files, so careful with those wildcards.

Inoffensive

IMO reset is the best one since you could have deleted the file. It's too bad that there's 1000 upvotes on add. – Haruspicy

Answer 18

Tell the command to automatically stage files that have been modified and deleted, but new files you have not told Git about are not affected:

-a
--all

git add . && git commit -m -a "Your commit"

or

git add --all && git commit -m "Your commit"

Octahedron

git add --all && git commit -m "Your commit" This worked for me in windows-7, using Git bash command shell. – Kalmuck

The following command worked for me in windows-7, using Git bash command shell: $ git add --all && git commit -m "remove property files" [master 58c41ac] remove property files 1 file changed, 9 deletions(-) ... Then to push those committed changes to the remote repository have run: $ git push origin .. Counting objects: 10, done. – Kalmuck

Answer 19

The following will work, even if you have a lot of files to process:

git ls-files --deleted | xargs git rm

You'll probably also want to commit with a comment.

For details, see: Useful Git Scripts

Amieeamiel

Answer 20

Please use -t to see which command is actually being ran

I just tweaked Virender answer to do same:

git ls-files --deleted -z | xargs -t -0 git rm

Ligure

Answer 21

None of the flags to git-add will only stage removed files; if all you have modified are deleted files, then you're fine, but otherwise, you need to run git-status and parse the output.

Working off of Jeremy's answer, this is what I got:

git status |  sed -s "s/^.*deleted: //" | grep "\(\#\|commit\)" -v | xargs git rm

1. Get status of files.
2. For deleted files, isolate the name of the file.
3. Remove all the lines that start with #s, as well as a status line that had the word "deleted" in it; I don't remember what it was, exactly, and it's not there any longer, so you may have to modify this for different situations. I think grouping of expressions might be a GNU-specific feature, so if you're not using gnutils, you may have to add multiple grep -v lines.
4. Pass the files to git rm.

Sticking this in a shell alias now...

Dulcet

Answer 22

git commit -m 'commit msg' $(git ls-files --deleted)

This worked for me after I had already deleted the files.

Undercast

Answer 23

I needed the same and used git gui "stage changed" button. it also adds all.

And after "stage changed" I made "commit" ...

so my working directory is clean again.

Hohenzollern

Well using a gui is CHEATING, lol! But faster in the cases where the GUI designer covered your needs. It is good to know how to tinker with 'what is under the hood'. – Herculaneum

FYI: this answer merged from #1403276 – Insulin

Answer 24

You can use git add -u <filenames> to stage the deleted files only.

For example, if you deleted the files templates/*.tpl, then use git add -u templates/*.tpl.

The -u is required in order to refer to files that exist in the repository but no longer exist in the working directory. Otherwise, the default of git add is to look for the files in the working directory, and if you specify files you've deleted there, it won't find them.

Pren

Answer 25

Adding system alias for staging deleted files as command rm-all

UNIX alias rm-all='git rm $(git ls-files --deleted)'

WINDOWS doskey rm-all=bash -c "git rm $(git ls-files --deleted)"

Note

Windows needs to have bash installed.

Ivett

Answer 26

(Yet another variation)

I wanted to delete all the already deleted from the disk files but from one specific folder, leaving the other folders untouched. The following worked for me:

git ls-files --deleted  | grep <folder-name> | xargs git rm

Sequestrate

Answer 27

something like

git status | sed -s "s/^.*deleted: //" | xargs git rm 

may do it.

Rother

2019 git version 2.13.3: git diff --diff-filter=D --name-only | xargs git rm – Saprophyte

Answer 28

For visual studio project

'git ls-files --deleted | sed 's/(.*)/"\1"/'| xargs git rm' 

which is useful when the deleted file path has space

Ageold

Answer 29

Deleting all files ending with .log from Repo but not local storage

git rm --cached $(git ls-files | grep "\.log$")

Subjoinder

Answer 30

Just simply

git add . && git commit -m "the message for commit" && git push

Plaque

Answer 31

You can commit all deleted files in Git by first using the command git add -u to stage the deleted files, and then using git commit -m "message" to commit the changes with a message describing the commit. The -u flag in the git add command stages all deleted files, as well as any other changes in the working directory.

Allard

Answer 32

The most flexible solution I have found to date is to

git cola

And select all deleted files I want to stage.

(Note I usually do everything commandline in git, but git handles removed files a bit awkward).

Naamann

Wildcards weren't working for me with git add -u path/to/my/deleted-files-pattern-*.yml so this was the best answer for me (not wanting to stage all deleted files, but 50 out of a couple hundred). – Hughey