support create new for a pep 723 script

package.json

@@ -209,6 +209,12 @@
                 "category": "Python Envs",
                 "icon": "$(terminal)"
             },
+            {
+                "command": "python-envs.createNewProjectFromTemplate",
+                "title": "%python-envs.createNewProjectFromTemplate.title%",
+                "category": "Python Envs",
+                "icon": "$(play)"
+            },
             {
                 "command": "python-envs.runAsTask",
                 "title": "%python-envs.runAsTask.title%",

package.nls.json

@@ -31,6 +31,7 @@
     "python-envs.runInTerminal.title": "Run in Terminal",
     "python-envs.createTerminal.title": "Create Python Terminal",
     "python-envs.runAsTask.title": "Run as Task",
+    "python-envs.createNewProjectFromTemplate.title": "Create New Project from Template",
     "python-envs.terminal.activate.title": "Activate Environment in Current Terminal",
     "python-envs.terminal.deactivate.title": "Deactivate Environment in Current Terminal",
     "python-envs.uninstallPackage.title": "Uninstall Package"

src/common/constants.ts

@@ -25,3 +25,5 @@ export const KNOWN_FILES = [
 ];
 
 export const KNOWN_TEMPLATE_ENDINGS = ['.j2', '.jinja2'];
+
+export const NEW_PROJECT_TEMPLATES_FOLDER = path.join(EXTENSION_ROOT_DIR, 'src', 'features', 'creators', 'templates');

src/common/pickers/managers.ts

@@ -1,8 +1,8 @@
-import { QuickPickItem, QuickPickItemKind } from 'vscode';
+import { commands, QuickInputButtons, QuickPickItem, QuickPickItemKind } from 'vscode';
 import { PythonProjectCreator } from '../../api';
 import { InternalEnvironmentManager, InternalPackageManager } from '../../internal.api';
 import { Common, Pickers } from '../localize';
-import { showQuickPick, showQuickPickWithButtons } from '../window.apis';
+import { showQuickPickWithButtons } from '../window.apis';
 
 function getDescription(mgr: InternalEnvironmentManager | InternalPackageManager): string | undefined {
     if (mgr.description) {
@@ -134,14 +134,88 @@ export async function pickCreator(creators: PythonProjectCreator[]): Promise<Pyt
         return creators[0];
     }
 
-    const items: (QuickPickItem & { c: PythonProjectCreator })[] = creators.map((c) => ({
+    // First level menu
+    const autoFindCreator = creators.find((c) => c.name === 'autoProjects');
+    const existingProjectsCreator = creators.find((c) => c.name === 'existingProjects');
+
+    const items: QuickPickItem[] = [
+        {
+            label: 'Auto Find',
+            description: autoFindCreator?.description ?? 'Automatically find Python projects',
+        },
+        {
+            label: 'Select Existing',
+            description: existingProjectsCreator?.description ?? 'Select existing Python projects',
+        },
+        {
+            label: 'Create New',
+            description: 'Create a Python project from a template',
+        },
+    ];
+
+    const selected = await showQuickPickWithButtons(items, {
+        placeHolder: Pickers.Managers.selectProjectCreator,
+        ignoreFocusOut: true,
+    });
+
+    if (!selected) {
+        return undefined;
+    }
+
+    // Return appropriate creator based on selection
+    // Handle case where selected could be an array (should not happen, but for type safety)
+    const selectedItem = Array.isArray(selected) ? selected[0] : selected;
+    if (!selectedItem) {
+        return undefined;
+    }
+    switch (selectedItem.label) {
+        case 'Auto Find':
+            return autoFindCreator;
+        case 'Select Existing':
+            return existingProjectsCreator;
+        case 'Create New':
+            return newProjectSelection(creators);
+    }
+
+    return undefined;
+}
+
+export async function newProjectSelection(creators: PythonProjectCreator[]): Promise<PythonProjectCreator | undefined> {
+    const otherCreators = creators.filter((c) => c.name !== 'autoProjects' && c.name !== 'existingProjects');
+
+    // Show second level menu for other creators
+    if (otherCreators.length === 0) {
+        return undefined;
+    }
+    const newItems: (QuickPickItem & { c: PythonProjectCreator })[] = otherCreators.map((c) => ({
         label: c.displayName ?? c.name,
         description: c.description,
         c: c,
     }));
-    const selected = await showQuickPick(items, {
-        placeHolder: Pickers.Managers.selectProjectCreator,
-        ignoreFocusOut: true,
-    });
-    return (selected as { c: PythonProjectCreator })?.c;
+    try {
+        const newSelected = await showQuickPickWithButtons(newItems, {
+            placeHolder: 'Select project type for new project',
+            ignoreFocusOut: true,
+            showBackButton: true,
+        });
+
+        if (!newSelected) {
+            // User cancelled the picker
+            return undefined;
+        }
+        // Handle back button
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if ((newSelected as any)?.kind === -1 || (newSelected as any)?.back === true) {
+            // User pressed the back button, re-show the first menu
+            return pickCreator(creators);
+        }
+
+        // Handle case where newSelected could be an array (should not happen, but for type safety)
+        const selectedCreator = Array.isArray(newSelected) ? newSelected[0] : newSelected;
+        return selectedCreator?.c;
+    } catch (ex) {
+        if (ex === QuickInputButtons.Back) {
+            await commands.executeCommand('python-envs.addPythonProject');
+        }
+    }
 }

src/extension.ts

@@ -1,10 +1,10 @@
 import { commands, ExtensionContext, LogOutputChannel, Terminal, Uri } from 'vscode';
-
 import { PythonEnvironment, PythonEnvironmentApi } from './api';
 import { ensureCorrectVersion } from './common/extVersion';
 import { registerTools } from './common/lm.apis';
 import { registerLogger, traceError, traceInfo } from './common/logging';
 import { setPersistentState } from './common/persistentState';
+import { newProjectSelection } from './common/pickers/managers';
 import { StopWatch } from './common/stopWatch';
 import { EventNames } from './common/telemetry/constants';
 import { sendManagerSelectionTelemetry } from './common/telemetry/helpers';
@@ -20,6 +20,8 @@ import { createManagerReady } from './features/common/managerReady';
 import { GetEnvironmentInfoTool, InstallPackageTool } from './features/copilotTools';
 import { AutoFindProjects } from './features/creators/autoFindProjects';
 import { ExistingProjects } from './features/creators/existingProjects';
+import { NewPackageProject } from './features/creators/newPackageProject';
+import { NewScriptProject } from './features/creators/newScriptProject';
 import { ProjectCreatorsImpl } from './features/creators/projectCreators';
 import {
     addPythonProjectCommand,
@@ -108,6 +110,8 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
         projectCreators,
         projectCreators.registerPythonProjectCreator(new ExistingProjects(projectManager)),
         projectCreators.registerPythonProjectCreator(new AutoFindProjects(projectManager)),
+        projectCreators.registerPythonProjectCreator(new NewPackageProject(envManagers, projectManager)),
+        projectCreators.registerPythonProjectCreator(new NewScriptProject(envManagers, projectManager)),
     );
 
     setPythonApi(envManagers, projectManager, projectCreators, terminalManager, envVarManager);
@@ -232,6 +236,12 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
                 await terminalManager.deactivate(terminal);
             }
         }),
+        commands.registerCommand('python-envs.createNewProjectFromTemplate', async () => {
+            const selected = await newProjectSelection(projectCreators.getProjectCreators());
+            if (selected) {
+                await selected.create();
+            }
+        }),
         terminalActivation.onDidChangeTerminalActivationState(async (e) => {
             await setActivateMenuButtonContext(e.terminal, e.environment, e.activated);
         }),

src/features/creators/creationHelpers.ts

@@ -0,0 +1,203 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { extensions, l10n, QuickInputButtons, Uri, window } from 'vscode';
+import { CreateEnvironmentOptions } from '../../api';
+import { traceError, traceVerbose } from '../../common/logging';
+import { showQuickPickWithButtons } from '../../common/window.apis';
+import { EnvironmentManagers, InternalEnvironmentManager } from '../../internal.api';
+
+/**
+ * Prompts the user to choose whether to create a new virtual environment (venv) for a project, with a clearer return and early exit.
+ * @returns {Promise<boolean | undefined>} Resolves to true if 'Yes' is selected, false if 'No', or undefined if cancelled.
+ */
+export async function promptForVenv(callback: () => void): Promise<boolean | undefined> {
+    try {
+        const venvChoice = await showQuickPickWithButtons([{ label: l10n.t('Yes') }, { label: l10n.t('No') }], {
+            placeHolder: l10n.t('Would you like to create a new virtual environment for this project?'),
+            ignoreFocusOut: true,
+            showBackButton: true,
+        });
+        if (!venvChoice) {
+            return undefined;
+        }
+        if (Array.isArray(venvChoice)) {
+            // Should not happen for single selection, but handle just in case
+            return venvChoice.some((item) => item.label === 'Yes');
+        }
+        return venvChoice.label === 'Yes';
+    } catch (ex) {
+        if (ex === QuickInputButtons.Back) {
+            callback();
+        }
+    }
+}
+
+/**
+ * Checks if the GitHub Copilot extension is installed in the current VS Code environment.
+ * @returns {boolean} True if Copilot is installed, false otherwise.
+ */
+export function isCopilotInstalled(): boolean {
+    return !!extensions.getExtension('GitHub.copilot');
+}
+
+/**
+ * Prompts the user to choose whether to create a Copilot instructions file, only if Copilot is installed.
+ * @returns {Promise<boolean | undefined>} Resolves to true if 'Yes' is selected, false if 'No', or undefined if cancelled or Copilot is not installed.
+ */
+export async function promptForCopilotInstructions(): Promise<boolean | undefined> {
+    if (!isCopilotInstalled()) {
+        return undefined;
+    }
+    const copilotChoice = await showQuickPickWithButtons([{ label: 'Yes' }, { label: 'No' }], {
+        placeHolder: 'Would you like to create a Copilot instructions file?',
+        ignoreFocusOut: true,
+        showBackButton: true,
+    });
+    if (!copilotChoice) {
+        return undefined;
+    }
+    if (Array.isArray(copilotChoice)) {
+        // Should not happen for single selection, but handle just in case
+        return copilotChoice.some((item) => item.label === 'Yes');
+    }
+    return copilotChoice.label === 'Yes';
+}
+
+/**
+ * Quickly creates a new Python virtual environment (venv) in the specified destination folder using the available environment managers.
+ * Attempts to use the venv manager if available, otherwise falls back to any manager that supports environment creation.
+ * @param envManagers - The collection of available environment managers.
+ * @param destFolder - The absolute path to the destination folder where the environment should be created.
+ * @returns {Promise<void>} Resolves when the environment is created or an error is shown.
+ */
+export async function quickCreateNewVenv(envManagers: EnvironmentManagers, destFolder: string) {
+    // get the environment manager for venv, should always exist
+    const envManager: InternalEnvironmentManager | undefined = envManagers.managers.find(
+        (m) => m.id === 'ms-python.python:venv',
+    );
+    const destinationUri = Uri.parse(destFolder);
+    if (envManager?.supportsQuickCreate) {
+        // with quickCreate enabled, user will not be prompted when creating the environment
+        const options: CreateEnvironmentOptions = { quickCreate: false };
+        if (envManager.supportsQuickCreate) {
+            options.quickCreate = true;
+        }
+        const pyEnv = await envManager.create(destinationUri, options);
+        // TODO: do I need to update to say this is the env for the file? Like set it?
+        if (!pyEnv) {
+            // comes back as undefined if this doesn't work
+            window.showErrorMessage(`Failed to create virtual environment, please create it manually.`);
+        } else {
+            traceVerbose(`Created venv at: ${pyEnv?.environmentPath}`);
+        }
+    } else {
+        window.showErrorMessage(`Failed to quick create virtual environment, please create it manually.`);
+    }
+}
+
+/**
+ * Replaces all occurrences of a string in file and folder names, as well as file contents, within a directory tree or a single file.
+ * @param targetPath - The root directory or file path to start the replacement from.
+ * @param searchValue - The string to search for in names and contents.
+ * @param replaceValue - The string to replace with.
+ * @returns {Promise<void>} Resolves when all replacements are complete.
+ */
+export async function replaceInFilesAndNames(targetPath: string, searchValue: string, replaceValue: string) {
+    const stat = await fs.stat(targetPath);
+
+    if (stat.isDirectory()) {
+        const entries = await fs.readdir(targetPath, { withFileTypes: true });
+        for (const entry of entries) {
+            let entryName = entry.name;
+            let fullPath = path.join(targetPath, entryName);
+            let newFullPath = fullPath;
+            // If the file or folder name contains searchValue, rename it
+            if (entryName.includes(searchValue)) {
+                const newName = entryName.replace(new RegExp(searchValue, 'g'), replaceValue);
+                newFullPath = path.join(targetPath, newName);
+                await fs.rename(fullPath, newFullPath);
+                entryName = newName;
+            }
+            await replaceInFilesAndNames(newFullPath, searchValue, replaceValue);
+        }
+    } else if (stat.isFile()) {
+        let content = await fs.readFile(targetPath, 'utf8');
+        if (content.includes(searchValue)) {
+            content = content.replace(new RegExp(searchValue, 'g'), replaceValue);
+            await fs.writeFile(targetPath, content, 'utf8');
+        }
+    }
+}
+
+/**
+ * Ensures the .github/copilot-instructions.md file exists at the given root, creating or appending as needed.
+ * Performs multiple find-and-replace operations as specified by the replacements array.
+ * @param destinationRootPath - The root directory where the .github folder should exist.
+ * @param instructionsFilePath - The path to the instructions template file.
+ * @param replacements - An array of tuples [{ text_to_find_and_replace, text_to_replace_it_with }]
+ */
+export async function manageCopilotInstructionsFile(
+    destinationRootPath: string,
+    instructionsFilePath: string,
+    replacements: Array<{ searchValue: string; replaceValue: string }>,
+) {
+    let instructionsText = `\n\n` + (await fs.readFile(instructionsFilePath, 'utf-8'));
+    for (const { searchValue: text_to_find_and_replace, replaceValue: text_to_replace_it_with } of replacements) {
+        instructionsText = instructionsText.replace(new RegExp(text_to_find_and_replace, 'g'), text_to_replace_it_with);
+    }
+    const githubFolderPath = path.join(destinationRootPath, '.github');
+    const customInstructionsPath = path.join(githubFolderPath, 'copilot-instructions.md');
+    if (!(await fs.pathExists(githubFolderPath))) {
+        await fs.mkdir(githubFolderPath);
+    }
+    const customInstructions = await fs.pathExists(customInstructionsPath);
+    if (customInstructions) {
+        await fs.appendFile(customInstructionsPath, instructionsText);
+    } else {
+        await fs.writeFile(customInstructionsPath, instructionsText);
+    }
+}
+
+/**
+ * Appends a configuration object to the configurations array in a launch.json file.
+ * @param launchJsonPath - The absolute path to the launch.json file.
+ * @param projectLaunchConfig - The stringified JSON config to append.
+ */
+async function appendToJsonConfigs(launchJsonPath: string, projectLaunchConfig: string) {
+    let content = await fs.readFile(launchJsonPath, 'utf8');
+    const json = JSON.parse(content);
+    // If it's a VS Code launch config, append to configurations array
+    if (json && Array.isArray(json.configurations)) {
+        const configObj = JSON.parse(projectLaunchConfig);
+        json.configurations.push(configObj);
+        await fs.writeFile(launchJsonPath, JSON.stringify(json, null, 4), 'utf8');
+    } else {
+        traceError('Failed to add Project Launch Config to launch.json.');
+        return;
+    }
+}
+
+/**
+ * Updates the launch.json file in the .vscode folder to include the provided project launch configuration.
+ * @param destinationRootPath - The root directory where the .vscode folder should exist.
+ * @param projectLaunchConfig - The stringified JSON config to append.
+ */
+export async function manageLaunchJsonFile(destinationRootPath: string, projectLaunchConfig: string) {
+    const vscodeFolderPath = path.join(destinationRootPath, '.vscode');
+    const launchJsonPath = path.join(vscodeFolderPath, 'launch.json');
+    if (!(await fs.pathExists(vscodeFolderPath))) {
+        await fs.mkdir(vscodeFolderPath);
+    }
+    const launchJsonExists = await fs.pathExists(launchJsonPath);
+    if (launchJsonExists) {
+        // Try to parse and append to existing launch.json
+        await appendToJsonConfigs(launchJsonPath, projectLaunchConfig);
+    } else {
+        // Create a new launch.json with the provided config
+        const launchJson = {
+            version: '0.2.0',
+            configurations: [JSON.parse(projectLaunchConfig)],
+        };
+        await fs.writeFile(launchJsonPath, JSON.stringify(launchJson, null, 4), 'utf8');
+    }
+}