feat: Cache config entries by type for typed queries

Context:
The config cache only stored raw (untyped) values, so Bool and Path
queries always fell back to spawning individual git processes. Since
Git's --type flag canonicalizes values (e.g., expanding ~/... for
paths, normalizing yes/on/1 to true for bools), serving these from
the raw cache would return incorrect values.

Justification:
Instead of bypassing the cache for typed queries, we maintain a
separate cache per GitConfigurationType. Each cache is loaded with
the appropriate --type flag passed to 'git config list', so Git
performs canonicalization during the bulk load. This preserves the
correctness guarantee while extending the performance benefit to
all query types.

The cache result is now authoritative when loaded: if a key is not
found in the cache, we return 'not found' directly rather than
falling back to an individual git process call. This avoids a
redundant process spawn when the key genuinely doesn't exist.

Implementation:
Changed _cache from a single ConfigCache to a Dictionary keyed by
GitConfigurationType. EnsureCacheLoaded() now accepts a type
parameter and passes --no-type, --type=bool, or --type=path to the
git config list command. InvalidateCache() clears all type-specific
caches on any write operation.

Renamed TypedQuery_DoesNotUseCache test to
TypedQuery_CanonicalizesValues since typed queries now use their
own type-specific cache rather than bypassing the cache entirely.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: derrickstolee

src/shared/Core.Tests/GitConfigurationTests.cs

@@ -634,7 +634,7 @@ public void GitConfiguration_CacheLevelFilter_ReturnsOnlyLocalValues()
         }
 
         [Fact]
-        public void GitConfiguration_TypedQuery_DoesNotUseCache()
+        public void GitConfiguration_TypedQuery_CanonicalizesValues()
         {
             string repoPath = CreateRepository(out string workDirPath);
             ExecGit(repoPath, workDirPath, "config --local test.path ~/example").AssertSuccess();
@@ -647,7 +647,8 @@ public void GitConfiguration_TypedQuery_DoesNotUseCache()
             var git = new GitProcess(trace, trace2, processManager, gitPath, repoPath);
             IGitConfiguration config = git.GetConfiguration();
 
-            // Path type should not use cache (needs Git's canonicalization)
+            // 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);

src/shared/Core/GitConfiguration.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Text;
 
 namespace GitCredentialManager
@@ -336,7 +337,7 @@ public class GitProcessConfiguration : IGitConfiguration
 
         private readonly ITrace _trace;
         private readonly GitProcess _git;
-        private readonly ConfigCache _cache;
+        private readonly Dictionary<GitConfigurationType, ConfigCache> _cache;
         private readonly bool _useCache;
 
         internal GitProcessConfiguration(ITrace trace, GitProcess git) : this(trace, git, useCache: true)
@@ -351,15 +352,44 @@ internal GitProcessConfiguration(ITrace trace, GitProcess git, bool useCache)
             _trace = trace;
             _git = git;
             _useCache = useCache;
-            _cache = useCache ? new ConfigCache() : null;
+            _cache = useCache ? new Dictionary<GitConfigurationType, ConfigCache>() : null;
         }
 
-        private void EnsureCacheLoaded()
+        private void EnsureCacheLoaded(GitConfigurationType type)
         {
-            if (!_useCache || _cache.IsLoaded)
+            ConfigCache cache;
+            if (!_useCache || (_cache.TryGetValue(type, out cache) && cache.IsLoaded))
+            {
+                return;
+            }
+
+            if (cache == null)
+            {
+                cache = new ConfigCache();
+                _cache[type] = cache;
+            }
+
+            string typeArg;
+
+            switch (type)
+            {
+            case GitConfigurationType.Raw:
+                typeArg = "--no-type";
+                break;
+
+            case GitConfigurationType.Path:
+                typeArg = "--type=path";
+                break;
+
+            case GitConfigurationType.Bool:
+                typeArg = "--type=bool";
+                break;
+
+            default:
                 return;
+            }
 
-            using (ChildProcess git = _git.CreateProcess("config list --show-origin -z"))
+            using (ChildProcess git = _git.CreateProcess($"config list --show-origin -z {typeArg}"))
             {
                 git.Start(Trace2ProcessClass.Git);
                 // To avoid deadlocks, always read the output stream first and then wait
@@ -369,7 +399,7 @@ private void EnsureCacheLoaded()
                 switch (git.ExitCode)
                 {
                     case 0: // OK
-                        _cache.Load(data, _trace);
+                        cache.Load(data, _trace);
                         break;
                     default:
                         _trace.WriteLine($"Failed to load config cache (exit={git.ExitCode})");
@@ -383,18 +413,24 @@ private void InvalidateCache()
         {
             if (_useCache)
             {
-                _cache.Clear();
+                foreach (ConfigCache cache in _cache.Values)
+                {
+                    cache.Clear();
+                }
             }
         }
 
         public void Enumerate(GitConfigurationLevel level, GitConfigurationEnumerationCallback cb)
         {
             if (_useCache)
             {
-                EnsureCacheLoaded();
-                if (_cache.IsLoaded)
+                EnsureCacheLoaded(GitConfigurationType.Raw);
+
+                ConfigCache cache = _cache[GitConfigurationType.Raw];
+
+                if (cache.IsLoaded)
                 {
-                    _cache.Enumerate(level, cb);
+                    cache.Enumerate(level, cb);
                     return;
                 }
             }
@@ -468,17 +504,19 @@ public void Enumerate(GitConfigurationLevel level, GitConfigurationEnumerationCa
 
         public bool TryGet(GitConfigurationLevel level, GitConfigurationType type, string name, out string value)
         {
-            // Use cache for raw types only - typed queries need Git's canonicalization
-            if (_useCache && type == GitConfigurationType.Raw)
+            if (_useCache)
             {
-                EnsureCacheLoaded();
-                if (_cache.IsLoaded && _cache.TryGet(name, level, out value))
+                EnsureCacheLoaded(type);
+
+                ConfigCache cache = _cache[type];
+                if (cache.IsLoaded)
                 {
-                    return true;
+                    // Cache is loaded, use it for the result (whether found or not)
+                    return cache.TryGet(name, level, out value);
                 }
             }
 
-            // Fall back to individual git config command for typed queries or cache miss
+            // Fall back to individual git config command if cache not available
             string levelArg = GetLevelFilterArg(level);
             string typeArg = GetCanonicalizeTypeArg(type);
             using (ChildProcess git = _git.CreateProcess($"config --null {levelArg} {typeArg} {QuoteCmdArg(name)}"))
@@ -583,13 +621,14 @@ public void Unset(GitConfigurationLevel level, string name)
 
         public IEnumerable<string> GetAll(GitConfigurationLevel level, GitConfigurationType type, string name)
         {
-            // Use cache for raw types only - typed queries need Git's canonicalization
-            if (_useCache && type == GitConfigurationType.Raw)
+            if (_useCache)
             {
-                EnsureCacheLoaded();
-                if (_cache.IsLoaded)
+                EnsureCacheLoaded(type);
+
+                ConfigCache cache = _cache[type];
+                if (cache.IsLoaded)
                 {
-                    var cachedValues = _cache.GetAll(name, level);
+                    var cachedValues = cache.GetAll(name, level);
                     foreach (var val in cachedValues)
                     {
                         yield return val;