create venv support

Author: eleanorjboyd

src/extension.ts

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

src/features/creators/creationHelpers.ts

@@ -1,6 +1,9 @@
-import { window, extensions } from 'vscode';
+import { window, extensions, Uri } from 'vscode';
 import * as fs from 'fs-extra';
 import * as path from 'path';
+import { EnvironmentManagers } from '../../internal.api';
+import { CreateEnvironmentOptions, EnvironmentManager } from '../../api';
+import { traceVerbose } from '../../common/logging';
 
 /**
  * Prompts the user to choose whether to create a new venv for a package.
@@ -49,17 +52,56 @@ export async function removeCopilotInstructions(destFolder: string) {
     }
 }
 
-export async function quickCreateNewVenv(destFolder: string) {
-    const venvPath = path.join(destFolder, '.venv');
+export async function quickCreateNewVenv(envManagers: EnvironmentManagers, destFolder: string) {
     try {
-        // Placeholder: replace with your venv creation logic
-        // await quickCreateVenv(...)
-        window.showInformationMessage(`(Placeholder) Would create venv at: ${venvPath}`);
+        // get the environment manager for venv
+        const envManager: EnvironmentManager | undefined = envManagers.managers.find(
+            (m) => m.id === 'ms-python.python:venv',
+        );
+        const destUri = Uri.parse(destFolder);
+        if (envManager && envManager.create) {
+            // with quickCreate enabled, user will not be prompted when creating the environment
+            const options: CreateEnvironmentOptions = { quickCreate: false };
+            if (envManager.quickCreateConfig) {
+                options.quickCreate = true;
+            }
+            const pyEnv = await envManager.create(destUri, options);
+            // comes back as undefined if this doesn't work
+            traceVerbose(`Created venv at: ${pyEnv?.environmentPath} using ${envManager.name}`);
+        } else {
+            // find an environment manager that supports create
+            const envManager = envManagers.managers.find((m) => m.create);
+            if (envManager) {
+                const pyEnv = await envManager.create(destUri, {});
+                traceVerbose(`Created venv at: ${pyEnv?.environmentPath} using ${envManager.name}`);
+            }
+            // If no environment manager supports create, show an error message
+            window.showErrorMessage(
+                `No environment manager found that supports creating a new environment, skipping...`,
+            );
+        }
     } catch (err) {
         window.showErrorMessage(`Failed to create virtual environment: ${err}`);
     }
 }
 
+/**
+ * Replaces all occurrences of a string in a single file's contents, handling special regex characters in the search value.
+ * @param filePath The path to the file to update.
+ * @param searchValue The string to search for (will be escaped for regex).
+ * @param replaceValue The string to replace with.
+ */
+export async function replaceInFile(filePath: string, searchValue: string, replaceValue: string) {
+    // Escape special regex characters in searchValue
+    const escapedSearchValue = searchValue.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(escapedSearchValue, 'g');
+    let content = await fs.readFile(filePath, 'utf8');
+    if (content.includes(searchValue)) {
+        content = content.replace(regex, replaceValue);
+        await fs.writeFile(filePath, content, 'utf8');
+    }
+}
+
 // Helper to recursively replace all occurrences of a string in file/folder names and file contents
 export async function replaceInFilesAndNames(dir: string, searchValue: string, replaceValue: string) {
     const entries = await fs.readdir(dir, { withFileTypes: true });

src/features/creators/newPackageProject.ts

@@ -9,16 +9,18 @@ import {
     quickCreateNewVenv,
     removeCopilotInstructions,
     replaceInFilesAndNames,
+    replaceInFile,
 } from './creationHelpers';
 import { EXTENSION_ROOT_DIR } from '../../common/constants';
+import { EnvironmentManagers } from '../../internal.api';
 
 export class NewPackageProject implements PythonProjectCreator {
     public readonly name = 'newPackage';
     public readonly displayName = 'Package';
     public readonly description = 'Create a new Python package';
     public readonly tooltip = new MarkdownString('Create a new Python package');
 
-    constructor() {}
+    constructor(private readonly envManagers: EnvironmentManagers) {}
 
     async create(_options?: PythonProjectCreatorOptions): Promise<PythonProject | undefined> {
         // Prompt for package name
@@ -30,7 +32,7 @@ export class NewPackageProject implements PythonProjectCreator {
             return undefined;
         }
 
-        // Use helper for venv
+        // Use helper to prompt for virtual environment creation
         const createVenv = await promptForVenv();
         if (createVenv === undefined) {
             return undefined;
@@ -83,9 +85,26 @@ export class NewPackageProject implements PythonProjectCreator {
 
         // 4. Create virtual environment if requested
         if (createVenv) {
-            await quickCreateNewVenv(destFolder);
+            await quickCreateNewVenv(this.envManagers, destFolder);
         }
 
+        // 5. Replace <run_exec> and <activation_command> in README.md
+        const readmeFilePath = path.join(destFolder, 'README.md');
+        const pythonEnvironment = await this.envManagers.getEnvironment(Uri.parse(destFolder));
+        if (!pythonEnvironment) {
+            window.showErrorMessage('Python environment not found.');
+            return undefined;
+        }
+        const execInfo = pythonEnvironment.execInfo;
+        if (execInfo.run) {
+            let execRunStr = execInfo.run.executable;
+            if (execInfo.run.args) {
+                execRunStr += ` ${execInfo.run.args.join(' ')}`;
+            }
+            await replaceInFile(readmeFilePath, '<run_exec>', execRunStr);
+        }
+        // TODO: replace <activation_command> in README.md ?
+
         // Return a PythonProject object if needed by your API
         return {
             name: packageName,