fix(util): normalize uppercase WSL drive letters in normalize_path

normalize_path's WSL branch matched only [a-z], so /mnt/C/foo matched
neither the WSL-conversion branch (regex miss) nor the Windows
drive-lowercasing branch (s[1] != ':') and was returned fully
unnormalized — wrong case and unconverted — violating the function's
own documented contract. Under a session that emitted an uppercase
/mnt/C path, this fragmented the session/cache key for the same
physical file. Widen the regex to [a-zA-Z] and lowercase the captured
drive so /mnt/C and /mnt/c collapse to one key.

Author: Zelys-DFKH

src/token_goat/util.py

@@ -48,7 +48,9 @@ def get_logger(name: str) -> Logger:
 
 
 # Compiled once at import time — avoids recompiling on every normalize_path call.
-_WSL_PATH_RE = re.compile(r"^/mnt/([a-z])/(.*)$", re.DOTALL)
+# Accept either case for the drive letter ([a-zA-Z]); the captured group is lowercased
+# below so /mnt/C/foo and /mnt/c/foo collapse to the same canonical key.
+_WSL_PATH_RE = re.compile(r"^/mnt/([a-zA-Z])/(.*)$", re.DOTALL)
 
 
 def normalize_path(path: str | Path) -> str:
@@ -92,7 +94,7 @@ def normalize_path(path: str | Path) -> str:
     # Step 2: convert WSL /mnt/<single-letter-drive>/rest → <drive>:/rest
     m = _WSL_PATH_RE.match(s)
     if m:
-        drive_letter = m.group(1)  # already lowercase due to [a-z] in regex
+        drive_letter = m.group(1).lower()  # lowercase so /mnt/C and /mnt/c agree
         rest = m.group(2)
         s = f"{drive_letter}:/{rest}"
     else:

tests/test_wsl_path_normalize.py

@@ -27,11 +27,24 @@ def test_wsl_path_with_subdirs(self) -> None:
         """WSL path with nested subdirectories converts correctly."""
         assert normalize_path("/mnt/c/Users/zelys/project/src/foo.py") == "c:/Users/zelys/project/src/foo.py"
 
-    def test_wsl_uppercase_drive_in_regex_does_not_apply(self) -> None:
-        """The /mnt/<drive>/ pattern only matches lowercase single letters."""
-        # /mnt/c/ → c:/  (lowercase drive letter preserved)
-        result = normalize_path("/mnt/c/bar")
-        assert result == "c:/bar"
+    def test_wsl_uppercase_c_drive(self) -> None:
+        """WSL /mnt/C/... (uppercase drive) normalizes to c:/... — drive lowercased.
+
+        Regression: the pre-fix regex was ``[a-z]`` only, so an uppercase /mnt/C/
+        path matched neither the WSL branch (regex miss) nor the Windows
+        drive-lowercasing branch (s[1] != ':'), and was returned fully
+        unnormalized, violating the documented WSL-conversion + lowercasing
+        contract and fragmenting the session/cache key for the same physical file.
+        """
+        assert normalize_path("/mnt/C/bar") == "c:/bar"
+
+    def test_wsl_uppercase_d_drive(self) -> None:
+        """WSL /mnt/D/... (uppercase non-C drive) normalizes to d:/..."""
+        assert normalize_path("/mnt/D/workspace") == "d:/workspace"
+
+    def test_wsl_uppercase_and_lowercase_same_key(self) -> None:
+        """/mnt/C/foo/bar and /mnt/c/foo/bar collapse to one canonical key."""
+        assert normalize_path("/mnt/C/foo/bar") == normalize_path("/mnt/c/foo/bar")
 
     def test_wsl_d_drive(self) -> None:
         """WSL /mnt/d/... converts to d:/..."""