Implement basic Pipenv registration and manager scaffolding

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

Author: Copilot

src/extension.ts

@@ -76,6 +76,7 @@ import {
 } from './managers/common/nativePythonFinder';
 import { IDisposable } from './managers/common/types';
 import { registerCondaFeatures } from './managers/conda/main';
+import { registerPipenvFeatures } from './managers/pipenv/main';
 import { registerPoetryFeatures } from './managers/poetry/main';
 import { registerPyenvFeatures } from './managers/pyenv/main';
 
@@ -562,6 +563,7 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
             registerSystemPythonFeatures(nativeFinder, context.subscriptions, outputChannel, sysMgr),
             registerCondaFeatures(nativeFinder, context.subscriptions, outputChannel),
             registerPyenvFeatures(nativeFinder, context.subscriptions),
+            registerPipenvFeatures(nativeFinder, context.subscriptions),
             registerPoetryFeatures(nativeFinder, context.subscriptions, outputChannel),
             shellStartupVarsMgr.initialize(),
         ]);

src/managers/pipenv/pipenvManager.ts

@@ -19,32 +19,32 @@ import { PipenvStrings } from '../../common/localize';
 import { NativePythonFinder } from '../common/nativePythonFinder';
 
 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;
 
     private readonly _onDidChangeEnvironments = new EventEmitter<DidChangeEnvironmentsEventArgs>();
     public readonly onDidChangeEnvironments = this._onDidChangeEnvironments.event;
-    constructor(private readonly nativeFinder: NativePythonFinder, private readonly api: PythonEnvironmentApi) {
+
+    public readonly name: string;
+    public readonly displayName: string;
+    public readonly preferredPackageManagerId: string;
+    public readonly description?: string;
+    public readonly tooltip: string | MarkdownString;
+    public readonly iconPath?: IconPath;
+
+    constructor(
+        public readonly nativeFinder: NativePythonFinder, 
+        public readonly api: PythonEnvironmentApi
+    ) {
         this.name = 'pipenv';
         this.displayName = 'Pipenv';
-        this.preferredPackageManagerId = 'ms-python.python:pip';
+        this.preferredPackageManagerId = 'ms-python.python:pipenv';
         this.tooltip = new MarkdownString(PipenvStrings.pipenvManager, true);
     }
 
-    name: string;
-    displayName: string;
-    preferredPackageManagerId: string;
-    description?: string;
-    tooltip: string | MarkdownString;
-    iconPath?: IconPath;
-
     public dispose() {
-        this.collection = [];
-        this.fsPathToEnv.clear();
+        this._onDidChangeEnvironment.dispose();
+        this._onDidChangeEnvironments.dispose();
     }
 
     quickCreateConfig?(): QuickCreateConfig | undefined {
@@ -65,29 +65,33 @@ export class PipenvManager implements EnvironmentManager {
     }
 
     async refresh(_scope: RefreshEnvironmentsScope): Promise<void> {
-        // To be implemented
+        // TODO: Implement pipenv environment refresh
+        // This should discover pipenv environments and update the collection
     }
 
     async getEnvironments(_scope: GetEnvironmentsScope): Promise<PythonEnvironment[]> {
-        // To be implemented
+        // TODO: Implement pipenv environment discovery
+        // This should return all discovered pipenv environments
         return [];
     }
 
     async set(_scope: SetEnvironmentScope, _environment?: PythonEnvironment): Promise<void> {
-        // To be implemented
+        // TODO: Implement setting pipenv environment for a scope
+        // This should update the selected environment for the given scope
     }
 
     async get(_scope: GetEnvironmentScope): Promise<PythonEnvironment | undefined> {
-        // To be implemented
+        // TODO: Implement getting the selected pipenv environment for a scope
         return undefined;
     }
 
     async resolve(_context: ResolveEnvironmentContext): Promise<PythonEnvironment | undefined> {
-        // To be implemented
+        // TODO: Implement resolving a path to a pipenv environment
         return undefined;
     }
 
     async clearCache?(): Promise<void> {
-        // To be implemented
+        // TODO: Implement cache clearing
+        // This should clear any cached environment discovery data
     }
 }

src/managers/pipenv/pipenvUtils.ts

@@ -1,11 +1,59 @@
 // Utility functions for Pipenv environment management
 
+import { traceInfo } from '../../common/logging';
+import { getWorkspacePersistentState } from '../../common/persistentState';
+import { ENVS_EXTENSION_ID } from '../../common/constants';
 import { NativePythonFinder } from '../common/nativePythonFinder';
+import which from 'which';
 
-export class PipenvUtils {
-    // Add static helper methods for pipenv operations here
+export const PIPENV_PATH_KEY = `${ENVS_EXTENSION_ID}:pipenv:PIPENV_PATH`;
+export const PIPENV_WORKSPACE_KEY = `${ENVS_EXTENSION_ID}:pipenv:WORKSPACE_SELECTED`;
+export const PIPENV_GLOBAL_KEY = `${ENVS_EXTENSION_ID}:pipenv:GLOBAL_SELECTED`;
+
+let pipenvPath: string | undefined;
+
+async function findPipenv(): Promise<string | undefined> {
+    try {
+        return await which('pipenv');
+    } catch {
+        return undefined;
+    }
 }
-export async function getPipenv(_native?: NativePythonFinder): Promise<string | undefined> {
-    // Implementation to find and return the pipenv path
+
+export async function clearPipenvCache(): Promise<void> {
+    pipenvPath = undefined;
+}
+
+export async function getPipenv(native?: NativePythonFinder): Promise<string | undefined> {
+    if (pipenvPath) {
+        return pipenvPath;
+    }
+
+    const state = await getWorkspacePersistentState();
+    pipenvPath = await state.get<string>(PIPENV_PATH_KEY);
+    if (pipenvPath) {
+        traceInfo(`Using pipenv from persistent state: ${pipenvPath}`);
+        return pipenvPath;
+    }
+
+    // Try to find pipenv in PATH
+    const foundPipenv = await findPipenv();
+    if (foundPipenv) {
+        pipenvPath = foundPipenv;
+        traceInfo(`Found pipenv in PATH: ${foundPipenv}`);
+        return foundPipenv;
+    }
+
+    // TODO: Add fallback to native finder when available
+    if (native) {
+        // Future enhancement: use native finder to locate pipenv
+        traceInfo('Native finder available but not yet implemented for pipenv detection');
+    }
+
+    traceInfo('Pipenv not found');
     return undefined;
 }
+
+export class PipenvUtils {
+    // Add static helper methods for pipenv operations here
+}