Port Python tools, and create a tool to quickly create a virtual env (#448)

Author: DonJayamanne

build/.mocha.unittests.json

@@ -1,6 +1,6 @@
 {
     "spec": "./out/test/**/*.unit.test.js",
-    "require": ["out/test/unittests.js"],
+    "require": ["source-map-support/register", "out/test/unittests.js"],
     "ui": "tdd",
     "recursive": true,
     "colors": true,

package.json

@@ -25,7 +25,11 @@
         }
     },
     "activationEvents": [
-        "onLanguage:python"
+        "onLanguage:python",
+        "onLanguageModelTool:get_python_environment_info",
+        "onLanguageModelTool:get_python_executable_info",
+        "onLanguageModelTool:install_python_package",
+        "onLanguageModelTool:create_quick_virtual_environment"
     ],
     "homepage": "https://github.com/microsoft/vscode-python-environments",
     "repository": {
@@ -515,15 +519,16 @@
         ],
         "languageModelTools": [
             {
-                "name": "python_environment",
-                "userDescription": "%python.languageModelTools.python_environment.userDescription%",
-                "displayName": "Get Python Environment Information",
-                "modelDescription": "Provides details about the Python environment for a specified file or workspace, including environment type, Python version, run command, and installed packages with their versions. Use this tool to determine the correct command for executing Python code in this workspace.",
-                "toolReferenceName": "pythonGetEnvironmentInfo",
+                "name": "get_python_environment_info",
+                "displayName": "%python.languageModelTools.get_python_environment_info.displayName%",
+                "userDescription": "%python.languageModelTools.get_python_environment_info.userDescription%",
+                "modelDescription": "This tool will retrieve the details of the Python Environment for the specified file or workspace. The details returned include the 1. Type of Environment (conda, venv, etec), 2. Version of Python, 3. List of all installed packages with their versions. ",
+                "toolReferenceName": "pythonEnvironmentDetails",
                 "tags": [
-                    "ms-python.python"
+                    "python",
+                    "extension_installed_by_tool"
                 ],
-                "icon": "$(files)",
+                "icon": "$(snake)",
                 "canBeReferencedInPrompt": true,
                 "inputSchema": {
                     "type": "object",
@@ -533,19 +538,42 @@
                         }
                     },
                     "description": "The path to the Python file or workspace to get the environment information for.",
-                    "required": [
-                        "resourcePath"
-                    ]
+                    "required": []
+                }
+            },
+            {
+                "name": "get_python_executable_info",
+                "displayName": "%python.languageModelTools.get_python_executable.displayName%",
+                "userDescription": "%python.languageModelTools.get_python_executable.userDescription%",
+                "modelDescription": "This tool will retrieve the details of the Python Environment for the specified file or workspace. ALWAYS use this tool before executing any Python command in the terminal. This tool returns the details of how to construct the fully qualified path and or command including details such as arguments required to run Python in a terminal. Note: Instead of executing `python --version` or `python -c 'import sys; print(sys.executable)'`, use this tool to get the Python executable path to replace the `python` command. E.g. instead of using `python -c 'import sys; print(sys.executable)'`, use this tool to build the command `conda run -n <env_name> -c 'import sys; print(sys.executable)'`.",
+                "toolReferenceName": "pythonExecutableDetails",
+                "tags": [
+                    "python",
+                    "extension_installed_by_tool"
+                ],
+                "icon": "$(files)",
+                "canBeReferencedInPrompt": true,
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "resourcePath": {
+                            "type": "string"
+                        }
+                    },
+                    "description": "The path to the Python file or workspace to get the executable information for. If not provided, the current workspace will be used. Where possible pass the path to the file or workspace.",
+                    "required": []
                 }
             },
             {
-                "name": "python_install_package",
-                "displayName": "Install Python Package",
-                "userDescription": "%python.languageModelTools.python_install_package.userDescription%",
+                "name": "install_python_package",
+                "displayName": "%python.languageModelTools.install_python_package.displayName%",
+                "userDescription": "%python.languageModelTools.install_python_package.userDescription%",
                 "modelDescription": "Installs Python packages in the given workspace. Use this tool to install packages in the user's chosen environment.",
-                "toolReferenceName": "pythonInstallPackage",
+                "toolReferenceName": "installPythonPackage",
                 "tags": [
-                    "ms-python.python"
+                    "python",
+                    "install python package",
+                    "extension_installed_by_tool"
                 ],
                 "icon": "$(package)",
                 "canBeReferencedInPrompt": true,
@@ -561,14 +589,38 @@
                         },
                         "resourcePath": {
                             "type": "string",
-                            "description": "The path to the Python file or workspace to get the environment information for."
+                            "description": "The path to the Python file or workspace into which the packages are installed. If not provided, the current workspace will be used. Where possible pass the path to the file or workspace."
                         }
                     },
                     "required": [
-                        "packageList",
-                        "resourcePath"
+                        "packageList"
                     ]
                 }
+            },
+            {
+                "name": "create_quick_virtual_environment",
+                "displayName": "Create a Virtual Environment",
+                "modelDescription": "This tool will create a Virual Environment",
+                "tags": [],
+                "canBeReferencedInPrompt": false,
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "packageList": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            },
+                            "description": "The list of packages to install."
+                        },
+                        "resourcePath": {
+                            "type": "string",
+                            "description": "The path to the Python file or workspace for which a Python Environment needs to be configured."
+                        }
+                    },
+                    "required": []
+                },
+                "when": "false"
             }
         ]
     },

package.nls.json

@@ -35,6 +35,10 @@
     "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",
-    "python.languageModelTools.python_environment.userDescription": "Get Python environment info for a file or path, including version, packages, and the command to run it.",
-    "python.languageModelTools.python_install_package.userDescription": "Installs Python packages in the given workspace."
+    "python.languageModelTools.get_python_environment_info.displayName": "Get Python Environment Info",
+    "python.languageModelTools.get_python_environment_info.userDescription": "Get information for a Python Environment, such as Type, Version, Packages, and more.",
+    "python.languageModelTools.install_python_package.displayName": "Install Python Package",
+    "python.languageModelTools.install_python_package.userDescription": "Installs Python packages in a Python Environment.",
+    "python.languageModelTools.get_python_executable.displayName": "Get Python Executable Info",
+    "python.languageModelTools.get_python_executable.userDescription": "Get executable info for a Python Environment"
 }

src/common/constants.ts

@@ -2,6 +2,7 @@ import * as path from 'path';
 
 export const ENVS_EXTENSION_ID = 'ms-python.vscode-python-envs';
 export const PYTHON_EXTENSION_ID = 'ms-python.python';
+export const JUPYTER_EXTENSION_ID = 'ms-toolsai.jupyter';
 export const EXTENSION_ROOT_DIR = path.dirname(__dirname);
 
 export const DEFAULT_PACKAGE_MANAGER_ID = 'ms-python.python:pip';
@@ -27,3 +28,4 @@ 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');
+export const NotebookCellScheme = 'vscode-notebook-cell';

src/extension.ts

@@ -16,7 +16,6 @@ import {
     onDidChangeTerminalShellIntegration,
 } from './common/window.apis';
 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';
@@ -69,6 +68,12 @@ import { createNativePythonFinder, NativePythonFinder } from './managers/common/
 import { registerCondaFeatures } from './managers/conda/main';
 import { registerPoetryFeatures } from './managers/poetry/main';
 import { registerPyenvFeatures } from './managers/pyenv/main';
+import { GetEnvironmentInfoTool } from './features/chat/getEnvInfoTool';
+import { GetExecutableTool } from './features/chat/getExecutableTool';
+import { InstallPackageTool } from './features/chat/installPackagesTool';
+import { CreateQuickVirtualEnvironmentTool } from './features/chat/createQuickVenvTool';
+import { createDeferred } from './common/utils/deferred';
+import { SysPythonManager } from './managers/builtin/sysPythonManager';
 
 export async function activate(context: ExtensionContext): Promise<PythonEnvironmentApi> {
     const start = new StopWatch();
@@ -125,7 +130,7 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
 
     setPythonApi(envManagers, projectManager, projectCreators, terminalManager, envVarManager);
     const api = await getPythonApi();
-
+    const sysPythonManager = createDeferred<SysPythonManager>();
     const managerView = new EnvManagerView(envManagers);
     context.subscriptions.push(managerView);
 
@@ -143,8 +148,19 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
     context.subscriptions.push(
         shellStartupVarsMgr,
         registerCompletionProvider(envManagers),
-        registerTools('python_environment', new GetEnvironmentInfoTool(api, envManagers)),
-        registerTools('python_install_package', new InstallPackageTool(api)),
+        registerTools(
+            CreateQuickVirtualEnvironmentTool.toolName,
+            new CreateQuickVirtualEnvironmentTool(
+                api,
+                envManagers,
+                projectManager,
+                sysPythonManager.promise,
+                outputChannel,
+            ),
+        ),
+        registerTools(GetEnvironmentInfoTool.toolName, new GetEnvironmentInfoTool(api, envManagers)),
+        registerTools(GetExecutableTool.toolName, new GetExecutableTool(api, envManagers)),
+        registerTools(InstallPackageTool.toolName, new InstallPackageTool(api)),
         commands.registerCommand('python-envs.terminal.revertStartupScriptChanges', async () => {
             await cleanupStartupScripts(shellStartupProviders);
         }),
@@ -314,8 +330,10 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
         // This is the finder that is used by all the built in environment managers
         const nativeFinder: NativePythonFinder = await createNativePythonFinder(outputChannel, api, context);
         context.subscriptions.push(nativeFinder);
+        const sysMgr = new SysPythonManager(nativeFinder, api, outputChannel);
+        sysPythonManager.resolve(sysMgr);
         await Promise.all([
-            registerSystemPythonFeatures(nativeFinder, context.subscriptions, outputChannel),
+            registerSystemPythonFeatures(nativeFinder, context.subscriptions, outputChannel, sysMgr),
             registerCondaFeatures(nativeFinder, context.subscriptions, outputChannel),
             registerPyenvFeatures(nativeFinder, context.subscriptions),
             registerPoetryFeatures(nativeFinder, context.subscriptions, outputChannel),

src/features/chat/createQuickVenvTool.ts

@@ -0,0 +1,96 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationToken,
+    l10n,
+    LanguageModelTextPart,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    LogOutputChannel,
+    PreparedToolInvocation,
+} from 'vscode';
+import { PythonEnvironmentApi } from '../../api';
+import { EnvironmentManagers, PythonProjectManager } from '../../internal.api';
+import { createAnyEnvironmentCommand } from '../envCommands';
+import { getEnvironmentDetails, resolveFilePath } from './utils';
+import { SysPythonManager } from '../../managers/builtin/sysPythonManager';
+import { ensureGlobalEnv } from '../../managers/builtin/venvUtils';
+
+export interface IResourceReference {
+    packageList?: string[];
+    resourcePath?: string;
+}
+
+export class CreateQuickVirtualEnvironmentTool implements LanguageModelTool<IResourceReference> {
+    public static readonly toolName = 'create_quick_virtual_environment';
+    constructor(
+        private readonly api: PythonEnvironmentApi,
+        private readonly envManagers: EnvironmentManagers,
+        private readonly projectManager: PythonProjectManager,
+        private readonly sysManager: Promise<SysPythonManager>,
+        private readonly log: LogOutputChannel,
+    ) {}
+    async invoke(
+        options: LanguageModelToolInvocationOptions<IResourceReference>,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult | undefined> {
+        const resourcePath = resolveFilePath(options.input.resourcePath);
+        const env = await createAnyEnvironmentCommand(this.envManagers, this.projectManager, {
+            selectEnvironment: true,
+            quickCreate: true,
+            uri: resourcePath,
+            additionalPackages:
+                Array.isArray(options.input.packageList) && options.input.packageList.length
+                    ? options.input.packageList
+                    : [],
+        });
+        if (env) {
+            const message = await getEnvironmentDetails(
+                resourcePath,
+                env,
+                this.api,
+                this.envManagers,
+                undefined,
+                token,
+            );
+            return new LanguageModelToolResult([new LanguageModelTextPart(message)]);
+        }
+    }
+
+    async prepareInvocation?(
+        _options: LanguageModelToolInvocationPrepareOptions<IResourceReference>,
+        _token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        let version = '';
+        try {
+            const sysMgr = await this.sysManager;
+            const globals = await sysMgr.getEnvironments('global');
+            const sortedEnvs = ensureGlobalEnv(globals, this.log);
+            version = getDisplayVersion(sortedEnvs[0].version);
+        } catch (ex) {
+            this.log.error('Failed to get Python version for quick virtual environment creation', ex);
+        }
+
+        return {
+            confirmationMessages: {
+                title: l10n.t('Create a Virtual Environment{0}?', version ? ` (${version})` : ''),
+                message: l10n.t(`Virtual Environments provide the benefit of package isolation and more.`),
+            },
+            invocationMessage: l10n.t('Creating a Virtual Environment'),
+        };
+    }
+}
+
+function getDisplayVersion(version: string): string {
+    if (!version) {
+        return '';
+    }
+    const parts = version.split('.');
+    if (parts.length < 3) {
+        return version;
+    }
+    return `${parts[0]}.${parts[1]}.${parts[2]}`;
+}

src/features/chat/getEnvInfoTool.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import {
+    CancellationToken,
+    l10n,
+    LanguageModelTextPart,
+    LanguageModelTool,
+    LanguageModelToolInvocationOptions,
+    LanguageModelToolInvocationPrepareOptions,
+    LanguageModelToolResult,
+    PreparedToolInvocation,
+} from 'vscode';
+import { PythonEnvironmentApi } from '../../api';
+import { EnvironmentManagers } from '../../internal.api';
+import { getPythonPackagesResponse } from './listPackagesTool';
+import { getEnvironmentDetails, getToolResponseIfNotebook, raceCancellationError, resolveFilePath } from './utils';
+
+export interface IResourceReference {
+    resourcePath?: string;
+}
+
+export class GetEnvironmentInfoTool implements LanguageModelTool<IResourceReference> {
+    public static readonly toolName = 'get_python_environment_info';
+    constructor(private readonly api: PythonEnvironmentApi, private readonly envManagers: EnvironmentManagers) {}
+    async invoke(
+        options: LanguageModelToolInvocationOptions<IResourceReference>,
+        token: CancellationToken,
+    ): Promise<LanguageModelToolResult> {
+        const resourcePath = resolveFilePath(options.input.resourcePath);
+        const notebookResponse = getToolResponseIfNotebook(resourcePath);
+        if (notebookResponse) {
+            return notebookResponse;
+        }
+        const environment = await raceCancellationError(this.api.getEnvironment(resourcePath), token);
+        if (!environment) {
+            throw new Error(`No environment found for the provided resource path ${resourcePath?.fsPath}`);
+        }
+
+        const packages = await getPythonPackagesResponse(environment, this.api, token);
+        const message = await getEnvironmentDetails(
+            resourcePath,
+            undefined,
+            this.api,
+            this.envManagers,
+            packages,
+            token,
+        );
+
+        return new LanguageModelToolResult([new LanguageModelTextPart(message)]);
+    }
+
+    async prepareInvocation?(
+        _options: LanguageModelToolInvocationPrepareOptions<IResourceReference>,
+        _token: CancellationToken,
+    ): Promise<PreparedToolInvocation> {
+        return {
+            invocationMessage: l10n.t('Fetching Python environment information'),
+        };
+    }
+}