fix: ensure the virtual environment is .venv for uv

Author: KingMichaelPark

lua/mason-core/installer/managers/pypi.lua

@@ -15,28 +15,40 @@ local spawn = require "mason-core.spawn"
 local M = {}
 
 local use_uv = settings.current.pip.use_uv
-local VENV_DIR = "venv"
+local VENV_DIR
+if use_uv then
+    VENV_DIR = ".venv"
+else
+    VENV_DIR = "venv"
+end
 
 ---@async
 ---@param candidates string[]
 local function resolve_python3(candidates)
     local is_executable = _.compose(_.equals(1), vim.fn.executable)
     a.scheduler()
-    if use_uv then
-        candidates = { "uv" }
-    end
     local available_candidates = _.filter(is_executable, candidates)
+    vim.print("starting resolve_python3")
     for __, candidate in ipairs(available_candidates) do
-        ---@type string
-        local version_output = spawn[candidate]({ "--version" }):map(_.prop "stdout"):get_or_else ""
-        local ok, version
-        if use_uv then
-            ok, version = pcall(semver.new, version_output:match "uv (%d+.%d+.%d+)")
-        else
-            ok, version = pcall(semver.new, version_output:match "Python (3%.%d+.%d+)")
-        end
-        if ok then
-            return { executable = candidate, version = version }
+        if use_uv and candidate == "uv" then
+            ---@type string
+            vim.print("Calling uv")
+            local version_output = spawn[candidate]({ "--version" }):map(_.prop "stdout"):get_or_else ""
+            vim.print("Got version output" .. version_output)
+            local ok, version = pcall(semver.new, version_output:match "uv (%d+.%d+.%d+).*")
+            vim.print("Ok is " .. tostring(ok))
+            vim.print("Version is " .. tostring(version))
+            if ok then
+                vim.print("Returning")
+                return { executable = candidate, version = version }
+            end
+        elseif not use_uv then
+            ---@type string
+            local version_output = spawn[candidate]({ "--version" }):map(_.prop "stdout"):get_or_else ""
+            local ok, version = pcall(semver.new, version_output:match "Python (3%.%d+.%d+)")
+            if ok then
+                return { executable = candidate, version = version }
+            end
         end
     end
     return nil
@@ -46,6 +58,7 @@ end
 ---@param specifiers string
 local function pep440_check_version(version, specifiers)
     -- The version check only implements a subset of the PEP440 specification and may error with certain inputs.
+    vim.print("starting pep440")
     local ok, result = pcall(pep440.check_version, version, specifiers)
     if not ok then
         log.fmt_warn(
@@ -61,6 +74,7 @@ end
 
 ---@param supported_python_versions string
 local function get_versioned_candidates(supported_python_versions)
+    vim.print("starting get_versioned_candidates")
     return _.filter_map(function(pair)
         local version, executable = unpack(pair)
         if not pep440_check_version(tostring(version), supported_python_versions) then
@@ -71,29 +85,30 @@ local function get_versioned_candidates(supported_python_versions)
         { semver.new "3.12.0", "python3.12" },
         { semver.new "3.11.0", "python3.11" },
         { semver.new "3.10.0", "python3.10" },
-        { semver.new "3.9.0", "python3.9" },
-        { semver.new "3.8.0", "python3.8" },
-        { semver.new "3.7.0", "python3.7" },
-        { semver.new "3.6.0", "python3.6" },
+        { semver.new "3.9.0",  "python3.9" },
+        { semver.new "3.8.0",  "python3.8" },
+        { semver.new "3.7.0",  "python3.7" },
+        { semver.new "3.6.0",  "python3.6" },
     })
 end
 
 ---@async
 ---@param pkg { name: string, version: string }
 local function create_venv(pkg)
+    vim.print("starting create_venv")
     local ctx = installer.context()
     ---@type string?
     local supported_python_versions = providers.pypi.get_supported_python_versions(pkg.name, pkg.version):get_or_nil()
 
     -- 1. Resolve stock python3 installation.
-    local stock_candidates = platform.is.win and { "python", "python3" } or { "python3", "python" }
+    local stock_candidates = platform.is.win and { "python", "python3", "uv" } or { "python3", "python", "uv" }
     local stock_target = resolve_python3(stock_candidates)
     if stock_target then
         log.fmt_debug("Resolved stock python3 installation version %s", stock_target.version)
     end
 
     -- 2. Resolve suitable versioned python3 installation (python3.12, python3.11, etc.).
-    local versioned_candidates = {}
+    local versioned_candidates = { "uv" }
     if supported_python_versions ~= nil then
         if stock_target and not pep440_check_version(tostring(stock_target.version), supported_python_versions) then
             log.fmt_debug("Finding versioned candidates for %s", supported_python_versions)
@@ -113,32 +128,35 @@ local function create_venv(pkg)
     -- 3. If a versioned python3 installation was not found, warn the user if the stock python3 installation is outside
     -- the supported version range.
     if
-        target == stock_target
+        use_uv == false
+        and target == stock_target
         and supported_python_versions ~= nil
         and not pep440_check_version(tostring(target.version), supported_python_versions)
     then
         if ctx.opts.force then
             ctx.stdio_sink.stderr(
-                ("Warning: The resolved python3 version %s is not compatible with the required Python versions: %s.\n"):format(
+                ("Warning: The resolved python3 version %s is not compatible with the required Python versions: %s.\n")
+                :format(
                     target.version,
                     supported_python_versions
                 )
             )
         else
             ctx.stdio_sink.stderr "Run with :MasonInstall --force to bypass this version validation.\n"
             return Result.failure(
-                ("Failed to find a python3 installation in PATH that meets the required versions (%s). Found version: %s."):format(
+                ("Failed to find a python3 installation in PATH that meets the required versions (%s). Found version: %s.")
+                :format(
                     supported_python_versions,
                     target.version
                 )
             )
         end
     end
 
-    log.fmt_debug("Found python3 installation version=%s, executable=%s", target.version, target.executable)
     ctx.stdio_sink.stdout "Creating virtual environment…\n"
-
+    print(vim.inspect("Creating virtualenv"))
     if use_uv then
+        print(vim.inspect("with uv"))
         log.fmt_debug("Found uv installation version=%s, executable=%s", target.version, target.executable)
         return ctx.spawn[target.executable] { "venv", VENV_DIR }
     else
@@ -170,6 +188,9 @@ end
 ---@param args SpawnArgs
 local function venv_python(args)
     local ctx = installer.context()
+    if use_uv then
+        return ctx.spawn[{ "uv", "venv" }](args)
+    end
     return find_venv_executable(ctx, "python"):and_then(function(python_path)
         return ctx.spawn[path.concat { ctx.cwd:get(), python_path }](args)
     end)
@@ -181,14 +202,14 @@ end
 local function pip_install(pkgs, extra_args)
     if use_uv then
         local ctx = installer.context()
+
         local task = ctx.spawn["uv"] {
             "pip",
             "install",
             "-U",
             extra_args or vim.NIL,
             pkgs,
         }
-        -- vim.api.nvim_set_current_dir(curdir)
         return task
     else
         return venv_python {