Implement core Pipenv utilities and manager functionality

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

Author: Copilot

src/managers/pipenv/pipenvManager.ts

@@ -1,24 +1,42 @@
-import { EventEmitter, MarkdownString } from 'vscode';
+import { EventEmitter, MarkdownString, ProgressLocation, Uri } from 'vscode';
 import {
     CreateEnvironmentOptions,
     CreateEnvironmentScope,
     DidChangeEnvironmentEventArgs,
     DidChangeEnvironmentsEventArgs,
+    EnvironmentChangeKind,
     EnvironmentManager,
     GetEnvironmentScope,
     GetEnvironmentsScope,
     IconPath,
     PythonEnvironment,
     PythonEnvironmentApi,
+    PythonProject,
     QuickCreateConfig,
     RefreshEnvironmentsScope,
     ResolveEnvironmentContext,
     SetEnvironmentScope,
 } from '../../api';
 import { PipenvStrings } from '../../common/localize';
+import { createDeferred, Deferred } from '../../common/utils/deferred';
+import { withProgress } from '../../common/window.apis';
 import { NativePythonFinder } from '../common/nativePythonFinder';
+import {
+    clearPipenvCache,
+    getPipenvForGlobal,
+    getPipenvForWorkspace,
+    refreshPipenv,
+    resolvePipenvPath,
+    setPipenvForGlobal,
+    setPipenvForWorkspace,
+    setPipenvForWorkspaces,
+} from './pipenvUtils';
 
 export class PipenvManager implements EnvironmentManager {
+    private collection: PythonEnvironment[] = [];
+    private fsPathToEnv: Map<string, PythonEnvironment> = new Map();
+    private globalEnv: PythonEnvironment | undefined;
+
     private readonly _onDidChangeEnvironment = new EventEmitter<DidChangeEnvironmentEventArgs>();
     public readonly onDidChangeEnvironment = this._onDidChangeEnvironment.event;
 
@@ -32,6 +50,8 @@ export class PipenvManager implements EnvironmentManager {
     public readonly tooltip: string | MarkdownString;
     public readonly iconPath?: IconPath;
 
+    private _initialized: Deferred<void> | undefined;
+
     constructor(
         public readonly nativeFinder: NativePythonFinder, 
         public readonly api: PythonEnvironmentApi
@@ -43,10 +63,63 @@ export class PipenvManager implements EnvironmentManager {
     }
 
     public dispose() {
+        this.collection = [];
+        this.fsPathToEnv.clear();
         this._onDidChangeEnvironment.dispose();
         this._onDidChangeEnvironments.dispose();
     }
 
+    async initialize(): Promise<void> {
+        if (this._initialized) {
+            return this._initialized.promise;
+        }
+
+        this._initialized = createDeferred();
+
+        await withProgress(
+            {
+                location: ProgressLocation.Window,
+                title: PipenvStrings.pipenvDiscovering,
+            },
+            async () => {
+                this.collection = await refreshPipenv(false, this.nativeFinder, this.api, this);
+                await this.loadEnvMap();
+
+                this._onDidChangeEnvironments.fire(
+                    this.collection.map((e) => ({ environment: e, kind: EnvironmentChangeKind.add })),
+                );
+            },
+        );
+        this._initialized.resolve();
+    }
+
+    private async loadEnvMap() {
+        // Load environment mappings for projects
+        const projects = this.api.getPythonProjects();
+        for (const project of projects) {
+            const envPath = await getPipenvForWorkspace(project.uri.fsPath);
+            if (envPath) {
+                const env = this.findEnvironmentByPath(envPath);
+                if (env) {
+                    this.fsPathToEnv.set(project.uri.fsPath, env);
+                }
+            }
+        }
+
+        // Load global environment
+        const globalEnvPath = await getPipenvForGlobal();
+        if (globalEnvPath) {
+            this.globalEnv = this.findEnvironmentByPath(globalEnvPath);
+        }
+    }
+
+    private findEnvironmentByPath(fsPath: string): PythonEnvironment | undefined {
+        return this.collection.find((env) => 
+            env.environmentPath.fsPath === fsPath || 
+            env.execInfo?.run.executable === fsPath
+        );
+    }
+
     quickCreateConfig?(): QuickCreateConfig | undefined {
         // To be implemented
         return undefined;
@@ -64,34 +137,162 @@ export class PipenvManager implements EnvironmentManager {
         // To be implemented
     }
 
-    async refresh(_scope: RefreshEnvironmentsScope): Promise<void> {
-        // TODO: Implement pipenv environment refresh
-        // This should discover pipenv environments and update the collection
+    async refresh(scope: RefreshEnvironmentsScope): Promise<void> {
+        const hardRefresh = scope === undefined; // hard refresh when scope is undefined
+        
+        await withProgress(
+            {
+                location: ProgressLocation.Window,
+                title: PipenvStrings.pipenvRefreshing,
+            },
+            async () => {
+                const oldCollection = [...this.collection];
+                this.collection = await refreshPipenv(hardRefresh, this.nativeFinder, this.api, this);
+                await this.loadEnvMap();
+
+                // Fire change events for environments that were added or removed
+                const changes: { environment: PythonEnvironment; kind: EnvironmentChangeKind }[] = [];
+                
+                // Find removed environments
+                oldCollection.forEach((oldEnv) => {
+                    if (!this.collection.find((newEnv) => newEnv.envId.id === oldEnv.envId.id)) {
+                        changes.push({ environment: oldEnv, kind: EnvironmentChangeKind.remove });
+                    }
+                });
+
+                // Find added environments
+                this.collection.forEach((newEnv) => {
+                    if (!oldCollection.find((oldEnv) => oldEnv.envId.id === newEnv.envId.id)) {
+                        changes.push({ environment: newEnv, kind: EnvironmentChangeKind.add });
+                    }
+                });
+
+                if (changes.length > 0) {
+                    this._onDidChangeEnvironments.fire(changes);
+                }
+            },
+        );
     }
 
-    async getEnvironments(_scope: GetEnvironmentsScope): Promise<PythonEnvironment[]> {
-        // TODO: Implement pipenv environment discovery
-        // This should return all discovered pipenv environments
+    async getEnvironments(scope: GetEnvironmentsScope): Promise<PythonEnvironment[]> {
+        await this.initialize();
+
+        if (scope === 'all') {
+            return Array.from(this.collection);
+        }
+
+        if (scope === 'global') {
+            // Return all environments for global scope
+            return Array.from(this.collection);
+        }
+
+        if (scope instanceof Uri) {
+            const project = this.api.getPythonProject(scope);
+            if (project) {
+                const env = this.fsPathToEnv.get(project.uri.fsPath);
+                return env ? [env] : [];
+            }
+        }
+
         return [];
     }
 
-    async set(_scope: SetEnvironmentScope, _environment?: PythonEnvironment): Promise<void> {
-        // TODO: Implement setting pipenv environment for a scope
-        // This should update the selected environment for the given scope
+    async set(scope: SetEnvironmentScope, environment?: PythonEnvironment): Promise<void> {
+        if (scope === undefined) {
+            // Global scope
+            const before = this.globalEnv;
+            this.globalEnv = environment;
+            await setPipenvForGlobal(environment?.environmentPath.fsPath);
+            
+            if (before?.envId.id !== this.globalEnv?.envId.id) {
+                this._onDidChangeEnvironment.fire({ uri: undefined, old: before, new: this.globalEnv });
+            }
+            return;
+        }
+
+        if (scope instanceof Uri) {
+            // Single project scope
+            const project = this.api.getPythonProject(scope);
+            if (!project) {
+                return;
+            }
+
+            const before = this.fsPathToEnv.get(project.uri.fsPath);
+            if (environment) {
+                this.fsPathToEnv.set(project.uri.fsPath, environment);
+            } else {
+                this.fsPathToEnv.delete(project.uri.fsPath);
+            }
+            
+            await setPipenvForWorkspace(project.uri.fsPath, environment?.environmentPath.fsPath);
+
+            if (before?.envId.id !== environment?.envId.id) {
+                this._onDidChangeEnvironment.fire({ uri: scope, old: before, new: environment });
+            }
+        }
+
+        if (Array.isArray(scope) && scope.every((u) => u instanceof Uri)) {
+            // Multiple projects scope
+            const projects: PythonProject[] = [];
+            scope
+                .map((s) => this.api.getPythonProject(s))
+                .forEach((p) => {
+                    if (p) {
+                        projects.push(p);
+                    }
+                });
+
+            const before: Map<string, PythonEnvironment | undefined> = new Map();
+            projects.forEach((p) => {
+                before.set(p.uri.fsPath, this.fsPathToEnv.get(p.uri.fsPath));
+                if (environment) {
+                    this.fsPathToEnv.set(p.uri.fsPath, environment);
+                } else {
+                    this.fsPathToEnv.delete(p.uri.fsPath);
+                }
+            });
+
+            await setPipenvForWorkspaces(
+                projects.map((p) => p.uri.fsPath),
+                environment?.environmentPath.fsPath,
+            );
+
+            projects.forEach((p) => {
+                const b = before.get(p.uri.fsPath);
+                if (b?.envId.id !== environment?.envId.id) {
+                    this._onDidChangeEnvironment.fire({ uri: p.uri, old: b, new: environment });
+                }
+            });
+        }
     }
 
-    async get(_scope: GetEnvironmentScope): Promise<PythonEnvironment | undefined> {
-        // TODO: Implement getting the selected pipenv environment for a scope
+    async get(scope: GetEnvironmentScope): Promise<PythonEnvironment | undefined> {
+        await this.initialize();
+
+        if (scope === undefined) {
+            return this.globalEnv;
+        }
+
+        if (scope instanceof Uri) {
+            const project = this.api.getPythonProject(scope);
+            if (project) {
+                return this.fsPathToEnv.get(project.uri.fsPath);
+            }
+        }
+
         return undefined;
     }
 
-    async resolve(_context: ResolveEnvironmentContext): Promise<PythonEnvironment | undefined> {
-        // TODO: Implement resolving a path to a pipenv environment
-        return undefined;
+    async resolve(context: ResolveEnvironmentContext): Promise<PythonEnvironment | undefined> {
+        await this.initialize();
+        return resolvePipenvPath(context.fsPath, this.nativeFinder, this.api, this);
     }
 
     async clearCache?(): Promise<void> {
-        // TODO: Implement cache clearing
-        // This should clear any cached environment discovery data
+        await clearPipenvCache();
+        this.collection = [];
+        this.fsPathToEnv.clear();
+        this.globalEnv = undefined;
+        this._initialized = undefined;
     }
 }