Pass the environment directory to uv package commands (#1742)

UV-backed package operations were constructed with
`environment.execInfo.run.executable`. For symlinked virtual
environments (e.g. Pipenv), that executable can resolve to a uv-managed
base interpreter, so `uv pip install --python <exe>` operated on the
externally managed base interpreter instead of the selected environment.

uv accepts an environment directory as its `--python` target, so the fix
is to hand UV commands `environment.environmentPath.fsPath` at the
pip/uv boundary. Ordinary pip commands still need the interpreter
executable.

### Changes

- **`src/managers/builtin/commands/factory.ts`**: when
`shouldUseUv(...)` selects uv, construct the UV command with a copy of
the options whose `pythonExecutable` is `environmentPath`. Pip commands
keep the original options.
- **`src/test/managers/builtin/commands.unit.test.ts`**: stub
`shouldUseUv` once in the existing setup and add regression coverage
that UV install/uninstall/list/direct-names all pass the environment
directory after `--python` and never the base interpreter, and that pip
still runs `runPython` with the original interpreter.

```ts
if (await shouldUseUv(options.log, environmentPath)) {
    // uv accepts an environment directory as its `--python` target. A symlinked
    // environment executable (for example Pipenv) can resolve to the externally
    // managed base interpreter, so passing the environment directory preserves
    // the environment boundary. Pip commands keep using the interpreter itself.
    return { kind: 'uv', command: new UvCommand({ ...options, pythonExecutable: environmentPath }) };
}
return { kind: 'pip', command: new PipCommand(options) };
```

Fixing this centrally covers every factory-created UV operation without
touching each command class. Call sites were reviewed:
`UvVersionCommand` (`uv --version`) and `UvAvailableVersionsCommand`
(`uv tool run pip index versions …`) don't reference `pythonExecutable`
in their arguments, so they're unaffected.

This adapts the intent of #1673 to the command-class refactor merged
later in #1686.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: edvilme <5952839+edvilme@users.noreply.github.com>

Author: Copilot

src/managers/builtin/commands/factory.ts

@@ -11,9 +11,14 @@ export async function createPipOrUvCommandWithKind<P, U>(
     PipCommand: CommandConstructor<P>,
     UvCommand: CommandConstructor<U>,
 ): Promise<PipOrUvCommand<P, U>> {
-    return (await shouldUseUv(options.log, environmentPath))
-        ? { kind: 'uv', command: new UvCommand(options) }
-        : { kind: 'pip', command: new PipCommand(options) };
+    if (await shouldUseUv(options.log, environmentPath)) {
+        // uv accepts an environment directory as its `--python` target. A symlinked
+        // environment executable (for example Pipenv) can resolve to the externally
+        // managed base interpreter, so passing the environment directory preserves
+        // the environment boundary. Pip commands keep using the interpreter itself.
+        return { kind: 'uv', command: new UvCommand({ ...options, pythonExecutable: environmentPath }) };
+    }
+    return { kind: 'pip', command: new PipCommand(options) };
 }
 
 export async function createPipOrUvCommand<T, P extends T, U extends T>(

src/test/managers/builtin/commands.unit.test.ts

@@ -13,9 +13,13 @@ import {
     PipAvailableVersionsTextCommand,
     UvAvailableVersionsCommand,
 } from '../../../managers/builtin/commands/availableVersions';
+import { createPipOrUvCommand } from '../../../managers/builtin/commands/factory';
 import { PipInstallCommand, UvInstallCommand } from '../../../managers/builtin/commands/install';
 import { PipListCommand, UvListCommand } from '../../../managers/builtin/commands/list';
-import { PipListDirectNamesCommand, UvListDirectNamesCommand } from '../../../managers/builtin/commands/listDirectNames';
+import {
+    PipListDirectNamesCommand,
+    UvListDirectNamesCommand,
+} from '../../../managers/builtin/commands/listDirectNames';
 import { PipUninstallCommand, UvUninstallCommand } from '../../../managers/builtin/commands/uninstall';
 import { PipVersionCommand, UvVersionCommand } from '../../../managers/builtin/commands/version';
 import * as helpers from '../../../managers/builtin/helpers';
@@ -28,6 +32,7 @@ suite('Pip and UV command parsing', () => {
     let mockLog: LogOutputChannel;
     let runPythonStub: sinon.SinonStub;
     let runUvStub: sinon.SinonStub;
+    let shouldUseUvStub: sinon.SinonStub;
 
     setup(() => {
         log = createMockLogOutputChannel();
@@ -37,6 +42,7 @@ suite('Pip and UV command parsing', () => {
         } as unknown as ReturnType<typeof workspaceApis.getConfiguration>);
         runPythonStub = sinon.stub(helpers, 'runPython').resolves('');
         runUvStub = sinon.stub(helpers, 'runUV').resolves('');
+        shouldUseUvStub = sinon.stub(helpers, 'shouldUseUv').resolves(false);
     });
 
     teardown(() => {
@@ -259,7 +265,10 @@ suite('Pip and UV command parsing', () => {
             '--python-version',
             '3.13.1',
         ]);
-        assert.deepStrictEqual(result.map((version) => version.public), ['1.0.0']);
+        assert.deepStrictEqual(
+            result.map((version) => version.public),
+            ['1.0.0'],
+        );
     });
 
     test('PipAvailableVersionsTextCommand parses text output for Pip 21.2 through 25.0', async () => {
@@ -282,7 +291,10 @@ suite('Pip and UV command parsing', () => {
             '--python-version',
             '3.13.1',
         ]);
-        assert.deepStrictEqual(result.map((version) => version.public), ['1.0.0']);
+        assert.deepStrictEqual(
+            result.map((version) => version.public),
+            ['1.0.0'],
+        );
     });
 
     test('UvAvailableVersionsCommand rejects output surrounding JSON', async () => {
@@ -319,7 +331,10 @@ suite('Pip and UV command parsing', () => {
         const result = await command.execute();
 
         assert.deepStrictEqual(runUvStub.firstCall.args[0], ['pip', 'list', '--format=json', '--python', 'python']);
-        assert.deepStrictEqual(result.map((pkg) => pkg.name), ['package']);
+        assert.deepStrictEqual(
+            result.map((pkg) => pkg.name),
+            ['package'],
+        );
     });
 
     test('direct-package commands normalize names and ignore UV dependencies', async () => {
@@ -349,4 +364,72 @@ suite('Pip and UV command parsing', () => {
         assert.strictEqual(pipVersion?.public, '24.0');
         assert.strictEqual(uvVersion?.public, '0.4.20');
     });
+
+    test('UV package commands target the environment directory rather than the resolved interpreter', async () => {
+        const baseInterpreter = path.join(path.sep, 'uv', 'python', 'cpython-3.13', 'bin', 'python');
+        const environmentPath = path.join(path.sep, 'virtualenvs', 'pipenv-project');
+        shouldUseUvStub.resolves(true);
+        const options = { pythonExecutable: baseInterpreter, log: mockLog };
+
+        const install: PipInstallCommand | UvInstallCommand = await createPipOrUvCommand(
+            options,
+            environmentPath,
+            PipInstallCommand,
+            UvInstallCommand,
+        );
+        await install.execute({ packages: [{ packageName: 'requests' }] });
+
+        const uninstall: PipUninstallCommand | UvUninstallCommand = await createPipOrUvCommand(
+            options,
+            environmentPath,
+            PipUninstallCommand,
+            UvUninstallCommand,
+        );
+        await uninstall.execute({ packages: [{ packageName: 'requests' }] });
+
+        const list: PipListCommand | UvListCommand = await createPipOrUvCommand(
+            options,
+            environmentPath,
+            PipListCommand,
+            UvListCommand,
+        );
+        runUvStub.resolves('[]');
+        await list.execute();
+
+        const directNames: PipListDirectNamesCommand | UvListDirectNamesCommand = await createPipOrUvCommand(
+            options,
+            environmentPath,
+            PipListDirectNamesCommand,
+            UvListDirectNamesCommand,
+        );
+        runUvStub.resolves('');
+        await directNames.execute();
+
+        assert.strictEqual(runPythonStub.callCount, 0);
+        assert.strictEqual(runUvStub.callCount, 4);
+        for (const call of runUvStub.getCalls()) {
+            const args = call.args[0] as string[];
+            const pythonIndex = args.indexOf('--python');
+            assert.notStrictEqual(pythonIndex, -1);
+            assert.strictEqual(args[pythonIndex + 1], environmentPath);
+            assert.ok(!args.includes(baseInterpreter));
+        }
+    });
+
+    test('Pip package commands continue using the environment interpreter', async () => {
+        const pythonExecutable = path.join(path.sep, 'virtualenvs', 'project', 'bin', 'python');
+        const environmentPath = path.join(path.sep, 'virtualenvs', 'project');
+        shouldUseUvStub.resolves(false);
+
+        const install: PipInstallCommand | UvInstallCommand = await createPipOrUvCommand(
+            { pythonExecutable, log: mockLog },
+            environmentPath,
+            PipInstallCommand,
+            UvInstallCommand,
+        );
+        await install.execute({ packages: [{ packageName: 'requests' }] });
+
+        assert.strictEqual(runPythonStub.firstCall.args[0], pythonExecutable);
+        assert.ok(runUvStub.notCalled);
+    });
 });