simplified solution on gear

Author: eleanorjboyd

package.json

@@ -124,7 +124,7 @@
                 "python-envs.workspaceSearchPaths": {
                     "type": "array",
                     "description": "%python-envs.workspaceSearchPaths.description%",
-                    "default": [],
+                    "default": ["./**/.venv"],
                     "scope": "resource",
                     "items": {
                         "type": "string"
@@ -557,11 +557,6 @@
                     "group": "navigation",
                     "when": "view == env-managers"
                 },
-                {
-                    "command": "python-envs.managerSearch",
-                    "group": "navigation",
-                    "when": "view == env-managers"
-                },
                 {
                     "command": "python-envs.searchSettings",
                     "group": "navigation",

package.nls.json

@@ -11,8 +11,8 @@
     "python-envs.terminal.autoActivationType.shellStartup": "Activation using [shell integration](https://code.visualstudio.com/docs/terminal/shell-integration) or by modifying the terminal shell startup script. Enable `terminal.integrated.shellIntegration.enabled` or we may need to modify your shell startup scripts for the ideal experience.",
     "python-envs.terminal.autoActivationType.off": "No automatic activation of environments.",
     "python-envs.terminal.useEnvFile.description": "Controls whether environment variables from .env files and python.envFile setting are injected into terminals.",
-    "python-envs.globalSearchPaths.description": "Global search paths for Python environments. Absolute directory paths that are searched at the user level.\n\n**Legacy Setting Support:** This setting is merged with the legacy `python.venvPath` and `python.venvFolders` settings. All paths from these three settings are combined into a single list of search paths. The legacy settings `python.venvPath` and `python.venvFolders` will be deprecated in the future, after which this setting will fully replace them. Please consider migrating your paths to this setting.",
-    "python-envs.workspaceSearchPaths.description": "Workspace search paths for Python environments. Can be absolute paths or relative directory paths searched within the workspace.",
+    "python-envs.globalSearchPaths.description": "Absolute paths to search for Python environments across all workspaces. Use for shared environment folders like `~/envs`.",
+    "python-envs.workspaceSearchPaths.description": "Paths to search for environments in this workspace. Defaults to `./**/.venv` to find all `.venv` folders nested within your workspace.",
     "python-envs.terminal.revertStartupScriptChanges.title": "Revert Shell Startup Script Changes",
     "python-envs.reportIssue.title": "Report Issue",
     "python-envs.setEnvManager.title": "Set Environment Manager",

src/common/localize.ts

@@ -206,6 +206,12 @@ export namespace EnvManagerSearchStrings {
     export const fullWorkspaceSearchDescription = l10n.t('Search the entire workspace for environments');
     export const saveSearchPrompt = l10n.t('Save this search setting for future discovery?');
     export const dontShowAgain = l10n.t("Don't show again");
+    export const slowLoadingMessage = l10n.t(
+        'Environment discovery is taking longer than expected. This may be due to workspace search paths.',
+    );
+    export const openSettings = l10n.t('Open Settings');
+    export const removeWorkspaceSearch = l10n.t('Remove Workspace Search');
+    export const dontShowForWorkspace = l10n.t("Don't Show for This Workspace");
 }
 
 export namespace ActivationStrings {

src/extension.ts

@@ -65,7 +65,11 @@ import { TerminalEnvVarInjector } from './features/terminal/terminalEnvVarInject
 import { TerminalManager, TerminalManagerImpl } from './features/terminal/terminalManager';
 import { registerTerminalPackageWatcher } from './features/terminal/terminalPackageWatcher';
 import { getEnvironmentForTerminal } from './features/terminal/utils';
-import { handleEnvManagerSearchAction, openSearchSettings } from './features/views/envManagerSearch';
+import {
+    handleEnvManagerSearchAction,
+    openSearchSettings,
+    startSlowLoadingMonitor,
+} from './features/views/envManagerSearch';
 import { EnvManagerView } from './features/views/envManagersView';
 import { ProjectView } from './features/views/projectView';
 import { PythonStatusBarImpl } from './features/views/pythonStatusBar';
@@ -453,22 +457,31 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
      * Below are all the contributed features using the APIs.
      */
     setImmediate(async () => {
+        // Start monitoring for slow loading - will show notification if discovery takes too long
+        const cancelSlowLoadingMonitor = startSlowLoadingMonitor();
+
         // This is the finder that is used by all the built in environment managers
         const nativeFinder: NativePythonFinder = await createNativePythonFinder(outputChannel, api, context);
         nativeFinderDeferred.resolve(nativeFinder);
         context.subscriptions.push(nativeFinder);
         const sysMgr = new SysPythonManager(nativeFinder, api, outputChannel);
         sysPythonManager.resolve(sysMgr);
-        await Promise.all([
-            registerSystemPythonFeatures(nativeFinder, context.subscriptions, outputChannel, sysMgr),
-            registerCondaFeatures(nativeFinder, context.subscriptions, outputChannel, projectManager),
-            registerPyenvFeatures(nativeFinder, context.subscriptions, projectManager),
-            registerPipenvFeatures(nativeFinder, context.subscriptions, projectManager),
-            registerPoetryFeatures(nativeFinder, context.subscriptions, outputChannel, projectManager),
-            shellStartupVarsMgr.initialize(),
-        ]);
-
-        await applyInitialEnvironmentSelection(envManagers, projectManager, nativeFinder, api);
+
+        try {
+            await Promise.all([
+                registerSystemPythonFeatures(nativeFinder, context.subscriptions, outputChannel, sysMgr),
+                registerCondaFeatures(nativeFinder, context.subscriptions, outputChannel, projectManager),
+                registerPyenvFeatures(nativeFinder, context.subscriptions, projectManager),
+                registerPipenvFeatures(nativeFinder, context.subscriptions, projectManager),
+                registerPoetryFeatures(nativeFinder, context.subscriptions, outputChannel, projectManager),
+                shellStartupVarsMgr.initialize(),
+            ]);
+
+            await applyInitialEnvironmentSelection(envManagers, projectManager, nativeFinder, api);
+        } finally {
+            // Cancel the slow loading monitor once initialization completes (or fails)
+            cancelSlowLoadingMonitor();
+        }
 
         // Register manager-agnostic terminal watcher for package-modifying commands
         registerTerminalPackageWatcher(api, terminalActivation, outputChannel, context.subscriptions);

src/features/views/envManagerSearch.ts

@@ -9,6 +9,8 @@ import { EnvironmentManagers } from '../../internal.api';
 import { NativePythonFinder } from '../../managers/common/nativePythonFinder';
 
 const SUPPRESS_SAVE_PROMPT_KEY = 'python-envs.search.fullWorkspace.suppressSavePrompt';
+const SUPPRESS_SLOW_LOADING_KEY = 'python-envs.search.slowLoading.suppressPrompt';
+const SLOW_LOADING_THRESHOLD_MS = 10_000; // 10 seconds
 
 /**
  * Handles the Environment Managers view search action.
@@ -22,10 +24,13 @@ export async function handleEnvManagerSearchAction(
 }
 
 /**
- * Opens environment search settings.
+ * Opens environment search settings at workspace level.
  */
 export async function openSearchSettings(): Promise<void> {
-    await commands.executeCommand('workbench.action.openSettings', '@ext:ms-python.vscode-python-envs "search path"');
+    await commands.executeCommand(
+        'workbench.action.openWorkspaceSettings',
+        '@ext:ms-python.vscode-python-envs "search path"',
+    );
 }
 
 /**
@@ -105,3 +110,56 @@ export async function appendWorkspaceSearchPaths(searchPaths: string[]): Promise
     const nextPaths = [...currentPaths, ...filteredSearchPaths];
     await config.update('workspaceSearchPaths', nextPaths, ConfigurationTarget.Workspace);
 }
+
+/**
+ * Clears the workspace-level `workspaceSearchPaths` setting.
+ */
+export async function clearWorkspaceSearchPaths(): Promise<void> {
+    const config = getConfiguration('python-envs');
+    await config.update('workspaceSearchPaths', [], ConfigurationTarget.Workspace);
+    traceLog('Cleared workspace search paths');
+}
+
+/**
+ * Monitors environment refresh and shows a notification if it takes too long.
+ * Returns a cleanup function to cancel the timeout if refresh completes early.
+ */
+export function startSlowLoadingMonitor(): () => void {
+    let timeoutId: NodeJS.Timeout | undefined;
+    let notificationShown = false;
+
+    const showNotification = async (): Promise<void> => {
+        const state = await getWorkspacePersistentState();
+        const suppressNotification = await state.get<boolean>(SUPPRESS_SLOW_LOADING_KEY, false);
+        if (suppressNotification || notificationShown) {
+            return;
+        }
+        notificationShown = true;
+
+        const response = await window.showWarningMessage(
+            EnvManagerSearchStrings.slowLoadingMessage,
+            EnvManagerSearchStrings.openSettings,
+            EnvManagerSearchStrings.removeWorkspaceSearch,
+            EnvManagerSearchStrings.dontShowForWorkspace,
+        );
+
+        if (response === EnvManagerSearchStrings.openSettings) {
+            await openSearchSettings();
+        } else if (response === EnvManagerSearchStrings.removeWorkspaceSearch) {
+            await clearWorkspaceSearchPaths();
+        } else if (response === EnvManagerSearchStrings.dontShowForWorkspace) {
+            await state.set(SUPPRESS_SLOW_LOADING_KEY, true);
+        }
+    };
+
+    timeoutId = setTimeout(() => {
+        showNotification();
+    }, SLOW_LOADING_THRESHOLD_MS);
+
+    return () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = undefined;
+        }
+    };
+}

src/managers/common/nativePythonFinder.ts

@@ -8,11 +8,11 @@ import { PythonProjectApi } from '../../api';
 import { spawnProcess } from '../../common/childProcess.apis';
 import { ENVS_EXTENSION_ID, PYTHON_EXTENSION_ID } from '../../common/constants';
 import { getExtension } from '../../common/extension.apis';
-import { traceError, traceLog } from '../../common/logging';
+import { traceError, traceVerbose, traceWarn } from '../../common/logging';
 import { untildify, untildifyArray } from '../../common/utils/pathUtils';
 import { isWindows } from '../../common/utils/platformUtils';
 import { createRunningWorkerPool, WorkerPool } from '../../common/utils/workerPool';
-import { getConfiguration } from '../../common/workspace.apis';
+import { getConfiguration, getWorkspaceFolders } from '../../common/workspace.apis';
 import { noop } from './utils';
 
 // Timeout constants for JSON-RPC requests (in milliseconds)
@@ -697,23 +697,34 @@ export async function getAllExtraSearchPaths(): Promise<string[]> {
     // Get workspaceSearchPaths
     const workspaceSearchPaths = getWorkspaceSearchPaths();
 
-    // Keep workspaceSearchPaths entries as provided (no workspace prefixing).
+    // Resolve relative paths against workspace folders
     for (const searchPath of workspaceSearchPaths) {
         if (!searchPath || searchPath.trim() === '') {
             continue;
         }
 
-        searchDirectories.push(searchPath.trim());
+        const trimmedPath = searchPath.trim();
+
+        if (path.isAbsolute(trimmedPath)) {
+            // Absolute path - use as is
+            searchDirectories.push(trimmedPath);
+        } else {
+            // Relative path - resolve against all workspace folders
+            const workspaceFolders = getWorkspaceFolders();
+            if (workspaceFolders) {
+                for (const workspaceFolder of workspaceFolders) {
+                    const resolvedPath = path.resolve(workspaceFolder.uri.fsPath, trimmedPath);
+                    searchDirectories.push(resolvedPath);
+                }
+            } else {
+                traceWarn('No workspace folders found for relative search path:', trimmedPath);
+            }
+        }
     }
 
     // Remove duplicates and return
     const uniquePaths = Array.from(new Set(searchDirectories));
-    traceLog(
-        'getAllExtraSearchPaths completed. Total unique search directories:',
-        uniquePaths.length,
-        'Paths:',
-        uniquePaths,
-    );
+    traceVerbose('Environment search directories:', uniquePaths.length, 'paths');
     return uniquePaths;
 }
 
@@ -748,7 +759,7 @@ function getWorkspaceSearchPaths(): string[] {
             );
         }
 
-        // For workspace settings, prefer workspaceFolder > workspace
+        // For workspace settings, prefer workspaceFolder > workspace > default
         if (inspection?.workspaceFolderValue) {
             return inspection.workspaceFolderValue;
         }
@@ -757,8 +768,8 @@ function getWorkspaceSearchPaths(): string[] {
             return inspection.workspaceValue;
         }
 
-        // Default empty array (don't use global value for workspace settings)
-        return [];
+        // Use the default value from package.json
+        return inspection?.defaultValue ?? [];
     } catch (error) {
         traceError('Error getting workspaceSearchPaths:', error);
         return [];