fix: scope uv run setting lookup

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

src/features/execution/runAsTask.ts

@@ -35,7 +35,7 @@ export async function runAsTask(
 
     const args = environment.execInfo?.activatedRun?.args ?? environment.execInfo?.run.args ?? [];
     const allArgs = [...args, ...options.args];
-    const useUv = await shouldUseUv(undefined, environment.environmentPath.fsPath);
+    const useUv = await shouldUseUv(undefined, environment.environmentPath.fsPath, options.project?.uri);
 
     if (useUv) {
         allArgs.unshift('--python', executable);

src/managers/builtin/helpers.ts

@@ -1,4 +1,4 @@
-import { CancellationError, CancellationToken, LogOutputChannel } from 'vscode';
+import { CancellationError, CancellationToken, ConfigurationScope, LogOutputChannel } from 'vscode';
 import { spawnProcess } from '../../common/childProcess.apis';
 import { EventNames } from '../../common/telemetry/constants';
 import { sendTelemetryEvent } from '../../common/telemetry/sender';
@@ -40,7 +40,7 @@ export async function isUvInstalled(log?: LogOutputChannel): Promise<boolean> {
  * @param envPath - Optional environment path to check against UV environments list
  * @returns True if uv should be used, false otherwise. For UV environments, returns true if uv is installed. For other environments, checks the 'python-envs.alwaysUseUv' setting and uv availability.
  */
-export async function shouldUseUv(log?: LogOutputChannel, envPath?: string): Promise<boolean> {
+export async function shouldUseUv(log?: LogOutputChannel, envPath?: string, scope?: ConfigurationScope): Promise<boolean> {
     if (envPath) {
         // always use uv if the given environment is stored as a uv env
         const uvEnvs = await getUvEnvironments();
@@ -50,7 +50,7 @@ export async function shouldUseUv(log?: LogOutputChannel, envPath?: string): Pro
     }
 
     // For other environments, check the user setting
-    const config = getConfiguration('python-envs');
+    const config = getConfiguration('python-envs', scope);
     const alwaysUseUv = config.get<boolean>('alwaysUseUv', true);
 
     if (alwaysUseUv) {

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

@@ -171,6 +171,48 @@ suite('runAsTask Tests', () => {
             );
         });
 
+        test('should quote uv executable when needed', async () => {
+            const environment: PythonEnvironment = {
+                envId: { id: 'test-env', managerId: 'test-manager' },
+                name: 'Test Environment',
+                displayName: 'Test Environment',
+                displayPath: '/path/to/env',
+                version: '3.9.0',
+                environmentPath: Uri.file('/path/to/env'),
+                execInfo: {
+                    run: {
+                        executable: '/path/to/python',
+                        args: [],
+                    },
+                },
+                sysPrefix: '/path/to/env',
+            };
+
+            const options: PythonTaskExecutionOptions = {
+                name: 'Quoted UV Task',
+                args: ['script.py'],
+            };
+
+            const mockTaskExecution = {} as TaskExecution;
+
+            mockGetWorkspaceFolder.returns(undefined);
+            mockShouldUseUv.withArgs(undefined, environment.environmentPath.fsPath, undefined).resolves(true);
+            mockQuoteStringIfNecessary.withArgs('uv').returns('"uv"');
+            mockExecuteTask.resolves(mockTaskExecution);
+
+            await runAsTask(environment, options);
+
+            const taskArg = mockExecuteTask.firstCall.args[0] as Task;
+            const execution = taskArg.execution as ShellExecution;
+
+            assert.strictEqual(execution.command, '"uv"', 'Should quote the uv executable when required');
+            assert.deepStrictEqual(
+                execution.args,
+                ['run', '--python', '/path/to/python', 'script.py'],
+                'Should preserve uv arguments when quoting the executable',
+            );
+        });
+
         test('should create and execute task with regular run configuration when no activatedRun', async () => {
             // Mock - Environment without activatedRun
             const environment: PythonEnvironment = {
@@ -197,6 +239,7 @@ suite('runAsTask Tests', () => {
             const mockTaskExecution = {} as TaskExecution;
 
             mockGetWorkspaceFolder.withArgs(undefined).returns(undefined);
+            mockShouldUseUv.withArgs(undefined, environment.environmentPath.fsPath, undefined).resolves(false);
             mockQuoteStringIfNecessary.withArgs('/path/to/python').returns('/path/to/python');
             mockExecuteTask.resolves(mockTaskExecution);
 
@@ -214,6 +257,10 @@ suite('runAsTask Tests', () => {
                 mockTraceInfo.calledWith(sinon.match(/Running as task: \/path\/to\/python --default-arg test\.py/)),
                 'Should log execution with run args',
             );
+            const taskArg = mockExecuteTask.firstCall.args[0] as Task;
+            const execution = taskArg.execution as ShellExecution;
+            assert.strictEqual(execution.command, '/path/to/python', 'Should keep the python executable when uv is off');
+            assert.deepStrictEqual(execution.args, ['--default-arg', 'test.py'], 'Should keep the non-uv arguments');
         });
 
         test('should handle custom reveal option', async () => {