LongPath | drop-in library to support long paths in .NET | DevOps library

As @torek stated out in the comments: the .gitattribute text settings caused the problem. We committed those modified files and everything went well after that.

Solution

Delete the git installation folder (e.g.: C:\Program Files\Git) completely and install the latest git version from https://git-scm.com/downloads.

Seems like a git interanl config get corrupt.

Finally, after a research found the solution.

Project Typescript Build properties my project was referring to 2.5 as I mentioned above. In MicrosoftDKs location I had higher version.

Open Visual Studio Installer> modify 2017 > Unselect Typescript version 2.5 Click Save changes

Now this version is removed and msbuild defaulted to highest available without making Project reference changes.

Another alternative if you want you can upgrade from TypescriptBuild properties to "Use Latest Version" option instead of specifying any version. Make sure you are aware of any compatibility issues.

TL;DR summary: the root issue here is case-folding. You may wish to convince Git to rename all the files. (Files in Git's index, AKA staging area, are not in folders, they just have long names that seem to have folder-names embedded within them. The names you need to change are therefore all the ones that start with the lowercase "folder" string.) Alternatively, make your working tree match the Git commits: in Git, file names are case sensitive.

UPDATE : In the output of git ls-tree -r HEAD, my file is listed , albeit with a slight modification : what I called myfile.txt above for short is really a long file path with several directories. The corresponding entry in git ls-tree -r HEAD is an identical path except that the first directory is uncapitalized (I and the Unix system call it Depth_one but git calls it depth_one).

This, and the fact that you are on macOS—or at a lower level, using a case-insensitive file system—are the key items. I was able to reproduce your issue on my own Mac, although perhaps with a slightly different reproducer. (This sort of thing is why a Minimal Reproducible Example is so important here. Simplifying a problem to its nub is good, but simplifying it to the point where it's gone is no help at all!)

To reproduce the problem, I ran:

SQL is probably not the best tool to do this, but you can do it using a recursive CTE.

For example:

This is a simple one. Check the documentation to the installation types based on your OS. For linux, just follow these commands:

1. Download and install the Git command line extension. Once downloaded and installed, set up Git LFS for your user account by running:

error: invalid path ' Monthly internal audit code '

The filename has a leading and a trailing spaces and it seems you're on a graphical environment that doesn't allow such filenames.

The only way to fix it is to clone the repository on a Unix/Linux OS (try WSL2, docker, a virtual machine), fix the filename and commit.

See Hans' answer in this QA: Access files with long paths (over 260)

Basically, change your paths to use \\?\ as a prefix:

Btw, I modified your code as follows:

• Using Option Explicit
• Removing the Call keyword from function invocation statements, note that parentheses must be omitted when not using Call.
• Using camelCase for locals.

Running git pull is just running two Git commands:

• First, git pull runs git fetch. This obtains any new commits needed for the second command.
• Second, git pull runs ... well, this can be complicated. You are having it run the default, though: git merge.

Usually when git pull fails, one of these two commands that it runs is the one that actually failed. The second command fails more often unless you have a particularly flaky Internet connection. In your case, it's the git merge that failed.

The word failed is usually too strong, really. Most merges do not actually fail. They just stop in the middle of the operation due to a conflict (or two conflicts, in your particular case). But your merge is a little special. It really does have an internal failure, which repeats several times: