Auto Find: exclude markers inside each workspace folder's selected environment sysPrefix (#1843)

Fixes #406

Auto Find searches for `pyproject.toml` and `setup.py` but excludes only
`**/.venv/**`. As a result, packages installed in a selected environment
with any other directory name (for example
`custom-env/lib/.../site-packages/pkg/setup.py`) are offered as
projects. This PR drops those false positives using the `sysPrefix` of
the environment selected for each workspace folder.

### Changes
- **`AutoFindProjects`** (`src/features/creators/autoFindProjects.ts`)
  - Takes `EnvironmentManagers` as a new constructor dependency.
- After `findFiles` returns results, calls
`envManagers.getEnvironment(folder.uri)` once for each folder in
`getWorkspaceFolders()`. Only non-empty, absolute `sysPrefix` values are
kept.
- Drops markers at or below any of those prefixes using the existing
`isSameOrParentPath`, which already enforces path boundaries and handles
Windows case and separators.
- The filter runs **before** the "No projects found" and "already
registered" checks. If every match is inside an environment, the user
sees "No projects found", not a misleading "already exists as project"
warning.
- A lookup failure is logged with `traceWarn` and that folder is
skipped; discovery continues.
- **Wiring** (`src/extension.ts`): passes the existing `envManagers`
instance to `AutoFindProjects`.

```ts
const found = await findFiles('**/{pyproject.toml,setup.py}', '**/.venv/**');
const prefixes = found && found.length > 0 ? await this.getSelectedEnvironmentPrefixes() : [];
const files = found?.filter((uri) => !prefixes.some((prefix) => isSameOrParentPath(prefix, uri.fsPath)));
```

### Unchanged
- `**/.venv/**` exclusion, picker, de-duplication and registration.
- With no selected environment or no usable prefix, behaviour is the
same as before.

### Out of scope
- Inactive, unselected or global environments.
- Environments selected for nested projects.
- Symlinked environment paths.
- Environment refreshes, caches or watchers.
- Settings or API changes.
- **Add Existing**.

An environment that is not the selected one for any workspace folder is
still excluded only if it is named `.venv`.

### Tests (`autoFindProjects.unit.test.ts`)
- Constructor mocks updated.
- A `custom-env` selected environment excludes both marker types,
including a marker at the environment root. A real project next to it
and a similarly named sibling `custom-env-project` are still offered.
- With two workspace folders, each folder's prefix is applied separately
(one lookup per folder).
- An `undefined` prefix, a relative prefix and a thrown lookup each
leave existing behaviour unchanged.
- When every marker is inside an environment, "No projects found" is
shown with no picker, warning or registration.

---------

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/extension.ts

@@ -220,7 +220,7 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
     context.subscriptions.push(
         projectCreators,
         projectCreators.registerPythonProjectCreator(new ExistingProjects(projectManager)),
-        projectCreators.registerPythonProjectCreator(new AutoFindProjects(projectManager)),
+        projectCreators.registerPythonProjectCreator(new AutoFindProjects(projectManager, envManagers)),
         projectCreators.registerPythonProjectCreator(new NewPackageProject(envManagers, projectManager)),
         projectCreators.registerPythonProjectCreator(new NewScriptProject(projectManager)),
     );

src/features/creators/autoFindProjects.ts

@@ -1,15 +1,16 @@
 import * as path from 'path';
-import { Uri } from 'vscode';
+import { Uri, WorkspaceFolder } from 'vscode';
 import { PythonProject, PythonProjectCreator, PythonProjectCreatorOptions } from '../../api';
 import { ProjectCreatorString } from '../../common/localize';
-import { traceInfo } from '../../common/logging';
+import { traceInfo, traceWarn } from '../../common/logging';
 import { showErrorMessage, showQuickPickWithButtons, showWarningMessage } from '../../common/window.apis';
-import { findFiles } from '../../common/workspace.apis';
+import { findFiles, getWorkspaceFolders } from '../../common/workspace.apis';
+import type { EnvironmentManagers } from '../envManagers';
 import {
     PythonProjectManager,
     PythonProjectsImpl,
 } from '../projectManager';
-import { normalizePath } from '../../common/utils/pathUtils';
+import { isSameOrParentPath, normalizePath } from '../../common/utils/pathUtils';
 
 function getUniqueUri(uris: Uri[]): {
     label: string;
@@ -60,10 +61,52 @@ export class AutoFindProjects implements PythonProjectCreator {
 
     supportsQuickCreate = true;
 
-    constructor(private readonly pm: PythonProjectManager) {}
+    constructor(
+        private readonly pm: PythonProjectManager,
+        private readonly envManagers: EnvironmentManagers,
+    ) {}
+
+    /**
+     * Returns selected environment prefixes inside an open workspace folder.
+     * Lookup failures are logged and skipped.
+     */
+    private async getSelectedEnvironmentPrefixes(folders: readonly WorkspaceFolder[]): Promise<string[]> {
+        const prefixes = await Promise.all(
+            folders.map(async (folder) => {
+                try {
+                    const environment = await this.envManagers.getEnvironment(folder.uri);
+                    const prefix = environment?.sysPrefix;
+                    return prefix &&
+                        path.isAbsolute(prefix) &&
+                        folders.some((workspaceFolder) => isSameOrParentPath(workspaceFolder.uri.fsPath, prefix))
+                        ? prefix
+                        : undefined;
+                } catch (ex) {
+                    traceWarn(`Auto Find: failed to get environment for ${folder.uri.fsPath}`, ex);
+                    return undefined;
+                }
+            }),
+        );
+        return prefixes.filter((prefix): prefix is string => !!prefix);
+    }
 
     async create(_options?: PythonProjectCreatorOptions): Promise<PythonProject | PythonProject[] | undefined> {
-        const files = await findFiles('**/{pyproject.toml,setup.py}', '**/.venv/**');
+        const found = await findFiles('**/{pyproject.toml,setup.py}', '**/.venv/**');
+        // Exclude markers inside selected environments (e.g. installed packages in a custom-named venv).
+        const folders = found && found.length > 0 ? getWorkspaceFolders() ?? [] : [];
+        const prefixes = await this.getSelectedEnvironmentPrefixes(folders);
+        const files = found?.filter(
+            (uri) =>
+                !prefixes.some(
+                    (prefix) =>
+                        isSameOrParentPath(prefix, uri.fsPath) &&
+                        !folders.some(
+                            (folder) =>
+                                isSameOrParentPath(prefix, folder.uri.fsPath) &&
+                                isSameOrParentPath(folder.uri.fsPath, uri.fsPath),
+                        ),
+                ),
+        );
         if (!files || files.length === 0) {
             setImmediate(() => {
                 showErrorMessage('No projects found');