add resolution for default interpreter and respect setting

Author: eleanorjboyd

src/extension.ts

@@ -72,6 +72,7 @@ import { SysPythonManager } from './managers/builtin/sysPythonManager';
 import {
     createNativePythonFinder,
     getNativePythonToolsPath,
+    NativeEnvInfo,
     NativePythonFinder,
 } from './managers/common/nativePythonFinder';
 import { IDisposable } from './managers/common/types';
@@ -566,6 +567,8 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
             shellStartupVarsMgr.initialize(),
         ]);
 
+        resolveDefaultInterpreter(nativeFinder, envManagers, api);
+
         sendTelemetryEvent(EventNames.EXTENSION_MANAGER_REGISTRATION_DURATION, start.elapsedTime);
         await terminalManager.initialize(api);
         sendManagerSelectionTelemetry(projectManager);
@@ -589,6 +592,64 @@ export async function disposeAll(disposables: IDisposable[]): Promise<void> {
     );
 }
 
+/**
+ * Resolves and sets the default Python interpreter for the workspace based on the
+ * 'python.defaultInterpreterPath' setting and the selected environment manager.
+ * If the setting is present and no default environment manager is set (or is venv),
+ * attempts to resolve the interpreter path using the native finder, then creates and
+ * sets a PythonEnvironment object for the workspace.
+ *
+ * @param nativeFinder - The NativePythonFinder instance used to resolve interpreter paths.
+ * @param envManagers - The EnvironmentManagers instance containing all registered managers.
+ * @param api - The PythonEnvironmentApi for environment resolution and setting.
+ */
+async function resolveDefaultInterpreter(
+    nativeFinder: NativePythonFinder,
+    envManagers: EnvironmentManagers,
+    api: PythonEnvironmentApi,
+) {
+    const defaultInterpreterPath = getConfiguration('python').get<string>('defaultInterpreterPath');
+
+    if (defaultInterpreterPath) {
+        const defaultManager = getConfiguration('python-envs').get<string>('defaultEnvManager', 'undefined');
+        if (!defaultManager || defaultManager === 'ms-python.python:venv') {
+            // if user has defaultInterpreterPath and no defaultEnvManager set then resolve the defaultInterpreterPath setting
+            const resolved: NativeEnvInfo = await nativeFinder.resolve(defaultInterpreterPath);
+            if (resolved && resolved.executable) {
+                const resolvedEnv = await api.resolveEnvironment(Uri.file(resolved.executable));
+
+                let findEnvManager = envManagers.managers.find((m) => m.id === resolvedEnv?.envId.managerId);
+
+                if (!findEnvManager) {
+                    findEnvManager = envManagers.managers.find((m) => m.id === 'ms-python.python:system');
+                }
+                if (resolvedEnv) {
+                    const newEnv: PythonEnvironment = {
+                        envId: {
+                            id: resolvedEnv?.envId.id,
+                            managerId: resolvedEnv?.envId.managerId ?? '',
+                        },
+                        name: 'defaultInterpreterPath: ' + (resolved.version ?? ''),
+                        displayName: 'defaultInterpreterPath: ' + (resolved.version ?? ''),
+                        version: resolved.version ?? '',
+                        displayPath: defaultInterpreterPath ?? '',
+                        environmentPath: defaultInterpreterPath ? Uri.file(defaultInterpreterPath) : Uri.file(''),
+                        sysPrefix: resolved.arch ?? '',
+                        execInfo: {
+                            run: {
+                                executable: defaultInterpreterPath ?? '',
+                            },
+                        },
+                    };
+                    if (workspace.workspaceFolders?.[0] && findEnvManager) {
+                        await api.setEnvironment(workspace.workspaceFolders[0].uri, newEnv);
+                    }
+                }
+            }
+        }
+    }
+}
+
 export async function deactivate(context: ExtensionContext) {
     await disposeAll(context.subscriptions);
     context.subscriptions.length = 0; // Clear subscriptions to prevent memory leaks