Cache typed config with git config list --type=<X> (#2268)

In certain repos and on the Windows platform, `git-credential-manager`
can take 8-15 seconds before looking up a credential or having any
user-facing interaction. This is due to dozens of `git config --get`
processes that take 150-250 milliseconds each. The config keys that
cause this pain are `http.<url>.sslCAinfo` and `http.<url>.cookieFile`.
When `credential.useHttpPath` is enabled, each key is checked as `<url>`
is incrementally truncated by directory segment.

It would be best if we could call a single Git process to send multiple
config queries instead of running multiple processes.
gitgitgadget/git#2033 suggested this direction of a single process
solution, but it's very complicated! During review of that effort, it
was recommended to use `git config list` instead.

But then there's a different problem! In all released versions of Git,
`git config list` silently ignores the `--type` argument. We need the
`--type` argument to guarantee that the resulting output string matches
the `bool` or `path` formats.

The core Git change in gitgitgadget/git#2044 is now merged to `next` and
thus is queued for Git 2.54.0. (We should wait until it merges to
`master` before merging this change, just in case.) We can only check
compatibility using a version check since the original command silently
misbehaves.

This pull request allows for caching the list of all config values that
match the given types: bool, path, or none. These are loaded lazily so
if a command doesn't need one of the types then the command doesn't run.
We are also careful to clear this cache if GCM mutates the config.

Since we ask for Git config values using `--type=bool`, `--type=path`,
_and_ `--no-type`, we may launch three `git config list` commands to
satisfy these needs.

There is a possibility that this feature is fast-tracked into
microsoft/git, in which case the version check would need augmentation.
I have that available in derrickstolee#1 as
an example.

Disclaimer: I used Claude Code and GitHub Copilot CLI to assist with
this change. I carefully reviewed the changes and made adjustments based
on my own taste and testing.

I did an end-to-end performance test on a local monorepo and got these
results for improvements to no-op `git fetch` calls:

| Command | Mean [s] | Min [s] | Max [s] | Relative |
|:---|---:|---:|---:|---:|
| Without Cache | 14.986 ± 0.255 | 14.558 | 15.192 | 3.29 ± 0.17 |
| With Cache | 4.561 ± 0.223 | 4.390 | 4.935 | 1.00 |

Author: mjcheetham

src/shared/Core.Tests/GitConfigurationTests.cs

@@ -436,5 +436,225 @@ public void GitConfiguration_UnsetAll_All_ThrowsException()
             Assert.Throws<InvalidOperationException>(() =>
                 config.UnsetAll(GitConfigurationLevel.All, "core.foobar", Constants.RegexPatterns.Any));
         }
+
+        [Fact]
+        public void GitConfiguration_CacheTryGet_ReturnsValueFromCache()
+        {
+            string repoPath = CreateRepository(out string workDirPath);
+            ExecGit(repoPath, workDirPath, "config --local user.name john.doe").AssertSuccess();
+            ExecGit(repoPath, workDirPath, "config --local user.email john@example.com").AssertSuccess();
+
+            string gitPath = GetGitPath();
+            var trace = new NullTrace();
+            var trace2 = new NullTrace2();
+            var processManager = new TestProcessManager();
+
+            var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
+            IGitConfiguration config = git.GetConfiguration();
+
+            // First access loads cache
+            bool result1 = config.TryGet("user.name", false, out string value1);
+            Assert.True(result1);
+            Assert.Equal("john.doe", value1);
+
+            // Second access should use cache
+            bool result2 = config.TryGet("user.email", false, out string value2);
+            Assert.True(result2);
+            Assert.Equal("john@example.com", value2);
+        }
+
+        [Fact]
+        public void GitConfiguration_CacheGetAll_ReturnsAllValuesFromCache()
+        {
+            string repoPath = CreateRepository(out string workDirPath);
+            ExecGit(repoPath, workDirPath, "config --local --add test.multi value1").AssertSuccess();
+            ExecGit(repoPath, workDirPath, "config --local --add test.multi value2").AssertSuccess();
+            ExecGit(repoPath, workDirPath, "config --local --add test.multi value3").AssertSuccess();
+
+            string gitPath = GetGitPath();
+            var trace = new NullTrace();
+            var trace2 = new NullTrace2();
+            var processManager = new TestProcessManager();
+
+            var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
+            IGitConfiguration config = git.GetConfiguration();
+
+            var values = new List<string>(config.GetAll("test.multi"));
+
+            Assert.Equal(3, values.Count);
+            Assert.Equal("value1", values[0]);
+            Assert.Equal("value2", values[1]);
+            Assert.Equal("value3", values[2]);
+        }
+
+        [Fact]
+        public void GitConfiguration_CacheEnumerate_EnumeratesFromCache()
+        {
+            string repoPath = CreateRepository(out string workDirPath);
+            ExecGit(repoPath, workDirPath, "config --local cache.name test-value").AssertSuccess();
+            ExecGit(repoPath, workDirPath, "config --local cache.enabled true").AssertSuccess();
+
+            string gitPath = GetGitPath();
+            var trace = new NullTrace();
+            var trace2 = new NullTrace2();
+            var processManager = new TestProcessManager();
+
+            var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
+            IGitConfiguration config = git.GetConfiguration();
+
+            var cacheEntries = new List<(string key, string value)>();
+            config.Enumerate(entry =>
+            {
+                if (entry.Key.StartsWith("cache."))
+                {
+                    cacheEntries.Add((entry.Key, entry.Value));
+                }
+                return true;
+            });
+
+            Assert.Equal(2, cacheEntries.Count);
+            Assert.Contains(("cache.name", "test-value"), cacheEntries);
+            Assert.Contains(("cache.enabled", "true"), cacheEntries);
+        }
+
+        [Fact]
+        public void GitConfiguration_CacheInvalidation_SetInvalidatesCache()
+        {
+            string repoPath = CreateRepository(out string workDirPath);
+            ExecGit(repoPath, workDirPath, "config --local test.value initial").AssertSuccess();
+
+            string gitPath = GetGitPath();
+            var trace = new NullTrace();
+            var trace2 = new NullTrace2();
+            var processManager = new TestProcessManager();
+
+            var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
+            IGitConfiguration config = git.GetConfiguration();
+
+            // Load cache with initial value
+            bool result1 = config.TryGet("test.value", false, out string value1);
+            Assert.True(result1);
+            Assert.Equal("initial", value1);
+
+            // Set new value (should invalidate cache)
+            config.Set(GitConfigurationLevel.Local, "test.value", "updated");
+
+            // Next read should get updated value
+            bool result2 = config.TryGet("test.value", false, out string value2);
+            Assert.True(result2);
+            Assert.Equal("updated", value2);
+        }
+
+        [Fact]
+        public void GitConfiguration_CacheInvalidation_AddInvalidatesCache()
+        {
+            string repoPath = CreateRepository(out string workDirPath);
+            ExecGit(repoPath, workDirPath, "config --local test.multi first").AssertSuccess();
+
+            string gitPath = GetGitPath();
+            var trace = new NullTrace();
+            var trace2 = new NullTrace2();
+            var processManager = new TestProcessManager();
+
+            var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
+            IGitConfiguration config = git.GetConfiguration();
+
+            // Load cache
+            var values1 = new List<string>(config.GetAll("test.multi"));
+            Assert.Single(values1);
+            Assert.Equal("first", values1[0]);
+
+            // Add new value (should invalidate cache)
+            config.Add(GitConfigurationLevel.Local, "test.multi", "second");
+
+            // Next read should include new value
+            var values2 = new List<string>(config.GetAll("test.multi"));
+            Assert.Equal(2, values2.Count);
+            Assert.Equal("first", values2[0]);
+            Assert.Equal("second", values2[1]);
+        }
+
+        [Fact]
+        public void GitConfiguration_CacheInvalidation_UnsetInvalidatesCache()
+        {
+            string repoPath = CreateRepository(out string workDirPath);
+            ExecGit(repoPath, workDirPath, "config --local test.value exists").AssertSuccess();
+
+            string gitPath = GetGitPath();
+            var trace = new NullTrace();
+            var trace2 = new NullTrace2();
+            var processManager = new TestProcessManager();
+
+            var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
+            IGitConfiguration config = git.GetConfiguration();
+
+            // Load cache
+            bool result1 = config.TryGet("test.value", false, out string value1);
+            Assert.True(result1);
+            Assert.Equal("exists", value1);
+
+            // Unset value (should invalidate cache)
+            config.Unset(GitConfigurationLevel.Local, "test.value");
+
+            // Next read should not find value
+            bool result2 = config.TryGet("test.value", false, out string value2);
+            Assert.False(result2);
+            Assert.Null(value2);
+        }
+
+        [Fact]
+        public void GitConfiguration_CacheLevelFilter_ReturnsOnlyLocalValues()
+        {
+            string repoPath = CreateRepository(out string workDirPath);
+
+            try
+            {
+                ExecGit(repoPath, workDirPath, "config --global test.level global-value").AssertSuccess();
+                ExecGit(repoPath, workDirPath, "config --local test.level local-value").AssertSuccess();
+
+                string gitPath = GetGitPath();
+                var trace = new NullTrace();
+                var trace2 = new NullTrace2();
+                var processManager = new TestProcessManager();
+
+                var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
+                IGitConfiguration config = git.GetConfiguration();
+
+                // Get local value only
+                bool result = config.TryGet(GitConfigurationLevel.Local, GitConfigurationType.Raw,
+                    "test.level", out string value);
+                Assert.True(result);
+                Assert.Equal("local-value", value);
+            }
+            finally
+            {
+                // Cleanup global config
+                ExecGit(repoPath, workDirPath, "config --global --unset test.level");
+            }
+        }
+
+        [Fact]
+        public void GitConfiguration_TypedQuery_CanonicalizesValues()
+        {
+            string repoPath = CreateRepository(out string workDirPath);
+            ExecGit(repoPath, workDirPath, "config --local test.path ~/example").AssertSuccess();
+
+            string gitPath = GetGitPath();
+            var trace = new NullTrace();
+            var trace2 = new NullTrace2();
+            var processManager = new TestProcessManager();
+
+            var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
+            IGitConfiguration config = git.GetConfiguration();
+
+            // Path type queries use a separate cache loaded with --type=path,
+            // so Git canonicalizes the values during cache load.
+            bool result = config.TryGet(GitConfigurationLevel.Local, GitConfigurationType.Path,
+                "test.path", out string value);
+            Assert.True(result);
+            Assert.NotNull(value);
+            // Value should be canonicalized path, not raw "~/example"
+            Assert.NotEqual("~/example", value);
+        }
     }
 }