Git: list only "untracked" files (also, custom commands)

Question

Is there a way to use a command like git ls-files to show only untracked files?

The reason I'm asking is because I use the following command to process all deleted files:

git ls-files -d | xargs git rm

I'd like something similar for untracked files:

git some-command --some-options | xargs git add

I was able to find the -o option to git ls-files, but this isn't what I want because it also shows ignored files. I was also able to come up with the following long and ugly command:

git status --porcelain | grep '^??' | cut -c4- | xargs git add

It seems like there's got to be a better command I can use here. And if there isn't, how do I create custom git commands?

Hydrolytic

Could you elaborate why do you need git ls-files -d | xargs git rm? – Shopkeeper

That removes all files that git notices are missing. My question was about how to do a related operation - add all files that git isn't currently tracking. I would usually do both of these after renaming, combining, and/or splitting my code files. – Hydrolytic

If they're missing, then aren't they already deleted? Unless... you pulled from somewhere else and then you're trying to synch with remote... I think I get it. – Loggia

I've tested all answers,if there's empty untracked folder, no one can find it. – Gladygladys

@Gladygladys this is correct. Because git works only on files, it does not have any way of tracking empty folders. Try find . -type d -empty instead. – Hydrolytic

Answer 1

To list untracked files try:

git ls-files --others --exclude-standard

If you need to pipe the output to xargs, it is wise to mind white spaces using git ls-files -z and xargs -0:

git ls-files -z -o --exclude-standard | xargs -0 git add

Nice alias for adding untracked files:

au = !git add $(git ls-files -o --exclude-standard)

Edit: For reference: git-ls-files

Shopkeeper

Perfect! What does the ! mean at the beginning of the alias line, or where is that documented? – Hydrolytic

@Shopkeeper How to get only parent directory names? not subfolders. Means in these untracked files: /P/a/files , /P/a/images , /P/a/ /P/ , ... - I just wanna list /P/ – Divert

In what situation would you need the alias though? git add * will do the same thing: add all untracked files excluding the standard (files who's paths are covered in .gitignore). – Fetich

I prefer my alias to work consistently in all directories in the repo (the ls-files command only shows changed files in the current tree), so I have [alias] lso = "!f() { cd $(git rev-parse --show-toplevel); git ls-files -o; }; f" – Ribbing

@takeshin,does it include files tracked by git-lfs ? – Gladygladys

@takeshin,this answer ignore empty folders. – Gladygladys

@WeAreAllMonica It is an alias to put in your .gitconfig. So the ! means run the comand in subshell. – Morales

Answer 2

If you just want to remove untracked files, do this:

warning this will remove all of you untracked files including directories

git clean -df

add x to that if you want to also include specifically ignored files. I use git clean -dfx a lot throughout the day.

You can create custom git by just writing a script called git-whatever and having it in your path.

Beatrizbeattie

It's much more common that I want to add all untracked files (for example, after I move some things around). In any case, thanks for the tip about custom commands. Where is that mechanism documented? – Hydrolytic

Just do git add -A or git add -u (depending on which makes more sense to you) – Beatrizbeattie

and "git clean -dfxn" for a dry run by adding "n" – Inkwell

Add -i to make it interactive. Can't recommend that enough. – Countrywoman

Answer 3

git add -A -n
will do what you want. -A adds all untracked and modified files to the repo, -n makes it a dry-run where the add isn't performed but the status output is given listing each file that would have been added.

Jedda

This is a great answer! Note that it excludes files in .gitignore files, which is usually what we want, but if not, git add -fAn. – Sigh

This seems like the best answer. – Yogh

This is THE best answer. It explicitly tells user what it would do (without doing it) and giving chance to review it before actually adding it. Perfect. Thanks! – Compost

It also lists modified files. – Trincomalee

nice, but I get it wrapped: add '$file'. Whereas git ls-files --exclude-standard -o gives a bare output, piping hot. – Pellicle

Just to say it clearly: This is not the searched-for answer. The original poster was looking for the bare file names without any ornamental characters (in order to process them by other commands), and without showing modified files, too. – Loferski

Answer 4

git status -u

will list all untracked files. Long form:

git status --untracked-files

Gorrono

how about a non-recursive version of that? – Renovate

Unfortunately, it also lists file ignored thru .gitignore files. – Burgh

This is the only answer that showed my ignored files on initial commit, but I had to add --ignored to the git status -u command – Rondi

This also shows modified files. So, not an answer to the question: only show untracked files. – Circumferential

this also outputs extra lines such as On branch ..., Untracked files: and (use "git add <file>..." to include in what will be committed) before as well as nothing added to commit but untracked files present (use "git add" to track) after the actual file list - which must be removed if the output is to be used as input for another command – Masseter

@Masseter add the flag --short to make that task much simpler – Ephor

Answer 5

The accepted answer crashes on filenames with space. I'm at this point not sure how to update the alias command, so I'll put the improved version here:

git ls-files -z -o --exclude-standard | xargs -0 git add

Underquote

I think this is the correct answer, because it provides the path of each file to perform an action (like git add) on them afterwards – Vogt

Answer 6

I know its an old question, but in terms of listing untracked files I thought I would add another one which also lists untracked folders:

You can used the git clean operation with -n (dry run) to show you which files it will remove (including the .gitignore files) by:

git clean -xdn

This has the advantage of showing all files and all folders that are not tracked. Parameters:

• x - Shows all untracked files (including ignored by git and others, like build output etc...)
• d - show untracked directories
• n - and most importantly! - dryrun, i.e. don't actually delete anything, just use the clean mechanism to display the results.

It can be a little bit unsafe to do it like this incase you forget the -n. So I usually alias it in git config.

Carrion

Why is git output so annoyingly human-readable? The proposed answer prints "Would remove" before each filename, so it's not usable for the OP's use case without further grepping. – Loferski

Answer 7

When looking for files to potentially add. The output from git show does that but it also includes a lot of other stuff. The following command is useful to get the same list of files but without all of the other stuff.

 git status --porcelain | grep "^?? " | sed -e 's/^[?]* //'

This is useful when combined in a pipeline to find files matching a specific pattern and then piping that to git add.

git status --porcelain | grep "^?? "  | sed -e 's/^[?]* //' | \
egrep "\.project$|\.settings$\.classfile$" | xargs -n1 git add

Blockade

Answer 8

All previous answers which I checked would list the files to be committed, too. Here is a simple and easy solution that only lists files which are not yet in the repo and not subject to .gitignore.

git status --porcelain | awk '/^\?\?/ { print $2; }'

or

git status --porcelain | grep -v '\?\?'

Wallinga

this doesn't seem to work well with files that have a space in their name – Masseter

Answer 9

I think I found a feature/problem with:

git ls-files --others --exclude-standard

wanting to list only untracked files:
if untracked file is in a modified directory, file will not be listed

Cramfull

Answer 10

I think this will do the same thing as the original poster intended:

git add .

Adding some caveats:

• You have run git status and confirmed your local directories are clean
• You have run git diff on each file reported in git status, and confirmed your changes are clean
• Your changes are covered with automated unit testing
• Your changes are covered with automated integration testing
• You have run the integration tests through a debugger, verifying the new behavior by white box observing the new code in action
• You have run all linting / code convention rules and they pass
• You have run all unit tests and they pass
• You have run all local integration tests, and they pass
• You have deployed your changes to an app review environment and manually tested them end to end in isolation from other changes
• You have merged latest from main branch and re-run all automated unit and integration testing, fixing any merge conflicts and test failures

Now, my friend, you are ready to git add . with impunity.

Wineglass

Every time you do git/svn add ., the kitten dies. – Glossology

Heh, only if you've got a bunch of cruft in your local copies of remote branches ;) Make local branches and you can git add . with impunity! – Wineglass

@Nakilon, that's why you configure .gitignore properly. Still good to avoid git add ., though. Better is git add -u. – Circumferential

Heh, been a long time @Glossology and @Wildcard. Updated the answer for clarity, there are definitely some assumptions about developer workflow that can impact safe usage of git add .. – Wineglass

Wasn't my downvote. Nice list though. It kind of shows that you need to do a lot of stuff anyway to be sure that you are doing the things right and that's why staging files in more precise way than just git add . should not be considered like something tedious. That was my point. 2013? Bad that things don't really change -- people still do it and that's the unobvious but real half of the reason to have pull requests and code reviews. Like a fighting the symptoms. Downvotes were probably because you also have to do git checkout . before that to not add changes. – Glossology