feat: map run button to uv run

Agent-Logs-Url: https://github.com/microsoft/vscode-python-environments/sessions/5f628821-9c7b-48a6-9f5f-9fccb9a33bf6

Co-authored-by: eleanorjboyd <26030610+eleanorjboyd@users.noreply.github.com>

Author: Copilot

package.nls.json

@@ -45,5 +45,5 @@
     "python-envs.revealProjectInExplorer.title": "Reveal Project in Explorer",
     "python-envs.revealEnvInManagerView.title": "Reveal in Environment Managers View",
     "python-envs.runPetInTerminal.title": "Run Python Environment Tool (PET) in Terminal...",
-    "python-envs.alwaysUseUv.description": "When set to true, uv will be used to manage all virtual environments if available. When set to false, uv will only manage virtual environments explicitly created by uv."
+    "python-envs.alwaysUseUv.description": "When set to true, uv will be used to manage all virtual environments if available, and the run button will execute files with uv run. When set to false, uv will only manage environments explicitly created by uv, including for the run button."
 }

src/features/execution/runAsTask.ts

@@ -12,6 +12,7 @@ import { PythonEnvironment, PythonTaskExecutionOptions } from '../../api';
 import { traceInfo, traceWarn } from '../../common/logging';
 import { executeTask } from '../../common/tasks.apis';
 import { getWorkspaceFolder } from '../../common/workspace.apis';
+import { shouldUseUv } from '../../managers/builtin/helpers';
 import { quoteStringIfNecessary } from './execUtils';
 
 function getWorkspaceFolderOrDefault(uri?: Uri): WorkspaceFolder | TaskScope {
@@ -31,11 +32,19 @@ export async function runAsTask(
         traceWarn('No Python executable found in environment; falling back to "python".');
         executable = 'python';
     }
-    // Check and quote the executable path if necessary
-    executable = quoteStringIfNecessary(executable);
 
     const args = environment.execInfo?.activatedRun?.args ?? environment.execInfo?.run.args ?? [];
     const allArgs = [...args, ...options.args];
+    const useUv = await shouldUseUv(undefined, environment.environmentPath.fsPath);
+
+    if (useUv) {
+        allArgs.unshift('--python', executable);
+        allArgs.unshift('run');
+        executable = 'uv';
+    }
+
+    // Check and quote the executable path if necessary
+    executable = quoteStringIfNecessary(executable);
     traceInfo(`Running as task: ${executable} ${allArgs.join(' ')}`);
 
     const task = new Task(

src/test/features/execution/runAsTask.unit.test.ts

@@ -7,20 +7,23 @@ import * as tasksApi from '../../../common/tasks.apis';
 import * as workspaceApis from '../../../common/workspace.apis';
 import * as execUtils from '../../../features/execution/execUtils';
 import { runAsTask } from '../../../features/execution/runAsTask';
+import * as builtinHelpers from '../../../managers/builtin/helpers';
 
 suite('runAsTask Tests', () => {
     let mockTraceInfo: sinon.SinonStub;
     let mockTraceWarn: sinon.SinonStub;
     let mockExecuteTask: sinon.SinonStub;
     let mockGetWorkspaceFolder: sinon.SinonStub;
     let mockQuoteStringIfNecessary: sinon.SinonStub;
+    let mockShouldUseUv: sinon.SinonStub;
 
     setup(() => {
         mockTraceInfo = sinon.stub(logging, 'traceInfo');
         mockTraceWarn = sinon.stub(logging, 'traceWarn');
         mockExecuteTask = sinon.stub(tasksApi, 'executeTask');
         mockGetWorkspaceFolder = sinon.stub(workspaceApis, 'getWorkspaceFolder');
         mockQuoteStringIfNecessary = sinon.stub(execUtils, 'quoteStringIfNecessary');
+        mockShouldUseUv = sinon.stub(builtinHelpers, 'shouldUseUv').resolves(false);
     });
 
     teardown(() => {
@@ -113,6 +116,61 @@ suite('runAsTask Tests', () => {
             assert.ok(mockTraceWarn.notCalled, 'Should not log warnings for valid environment');
         });
 
+        test('should use uv run when uv mode applies', async () => {
+            const environment: PythonEnvironment = {
+                envId: { id: 'test-env', managerId: 'test-manager' },
+                name: 'Test Environment',
+                displayName: 'Test Environment',
+                shortDisplayName: 'TestEnv',
+                displayPath: '/path/to/env',
+                version: '3.9.0',
+                environmentPath: Uri.file('/path/to/env'),
+                execInfo: {
+                    run: {
+                        executable: '/path/to/python',
+                        args: ['--default'],
+                    },
+                    activatedRun: {
+                        executable: '/activated/python',
+                        args: ['--activated'],
+                    },
+                },
+                sysPrefix: '/path/to/env',
+            };
+
+            const options: PythonTaskExecutionOptions = {
+                name: 'UV Task',
+                args: ['script.py', '--arg1'],
+            };
+
+            const mockTaskExecution = {} as TaskExecution;
+
+            mockGetWorkspaceFolder.returns(undefined);
+            mockShouldUseUv.withArgs(undefined, environment.environmentPath.fsPath).resolves(true);
+            mockQuoteStringIfNecessary.withArgs('uv').returns('uv');
+            mockExecuteTask.resolves(mockTaskExecution);
+
+            const result = await runAsTask(environment, options);
+
+            assert.strictEqual(result, mockTaskExecution, 'Should return the task execution result');
+
+            const taskArg = mockExecuteTask.firstCall.args[0] as Task;
+            const execution = taskArg.execution as ShellExecution;
+
+            assert.strictEqual(execution.command, 'uv', 'Should execute uv when uv mode is enabled');
+            assert.deepStrictEqual(
+                execution.args,
+                ['run', '--python', '/activated/python', '--activated', 'script.py', '--arg1'],
+                'Should prepend uv run arguments before the file arguments',
+            );
+            assert.ok(
+                mockTraceInfo.calledWith(
+                    sinon.match(/Running as task: uv run --python \/activated\/python --activated script\.py --arg1/),
+                ),
+                'Should log the uv run command',
+            );
+        });
+
         test('should create and execute task with regular run configuration when no activatedRun', async () => {
             // Mock - Environment without activatedRun
             const environment: PythonEnvironment = {