Add "Set as Working Directory" command (#5476)

This change adds a "Set as Working Directory" affordance to the
Explorer.

<img width="453" alt="image"
src="https://github.com/user-attachments/assets/4ed59ae6-8ef5-4697-81e4-059dfd59b81e">

This command sets the current working directory of the active Console to
the folder by emitting the appropriate R or Python code.

Addresses #4444. 

The only complicated/annoying bit is that in Python, the idiomatic way
to change the working directory is `os.chdir`, but that doesn't work
unless you've done an `import os` at some point. So we also have to
check to see if you have `os`, and if you haven't, tack on an `import
os` to the command.

I did not add an affordance going the other way (from the Console to the
Explorer). That one will need more thought because the Explorer can't
display folders outside your workspace, whereas the Console can enter
any legal working directory.

### QA Notes

- If it's helpful for testing, I also added this to the Palette, under
`Interpreter: Set as Working Directory`.
- Directory names should be properly escaped.

---------

Signed-off-by: Jonathan <[email protected]>
Co-authored-by: Pete <[email protected]>
Co-authored-by: Julia Silge <[email protected]>

Author: 3 people

extensions/jupyter-adapter/src/LanguageRuntimeAdapter.ts

@@ -265,6 +265,19 @@ export class LanguageRuntimeSessionAdapter
 		this._kernel.replyToPrompt(id, reply);
 	}
 
+	/**
+	 * Set the working directory for the kernel. This is a stub implementation since Jupyter
+	 * doesn't have a concept of a working directory.
+	 *
+	 * @param workingDirectory The working directory to set
+	 * @returns Nothing
+	 * @throws An error message indicating that this method is not implemented
+	 */
+	public setWorkingDirectory(workingDirectory: string): Promise<void> {
+		return Promise.reject(
+			`Cannot change working directory to ${workingDirectory} (not implemented)`);
+	}
+
 	/**
 	 * Interrupts the kernel.
 	 */

extensions/positron-javascript/src/session.ts

@@ -148,6 +148,10 @@ export class JavaScriptLanguageRuntimeSession implements positron.LanguageRuntim
 		throw new Error('Method not implemented.');
 	}
 
+	setWorkingDirectory(dir: string): Thenable<void> {
+		throw new Error('Method not implemented.');
+	}
+
 	async start(): Promise<positron.LanguageRuntimeInfo> {
 		this._onDidChangeRuntimeState.fire(positron.RuntimeState.Initializing);
 		this._onDidChangeRuntimeState.fire(positron.RuntimeState.Starting);

extensions/positron-python/python_files/positron/positron_ipykernel/positron_ipkernel.py

@@ -411,7 +411,7 @@ def __init__(self, **kwargs) -> None:
         # Create Positron services
         self.data_explorer_service = DataExplorerService(_CommTarget.DataExplorer, self.job_queue)
         self.plots_service = PlotsService(_CommTarget.Plot, self.session_mode)
-        self.ui_service = UiService()
+        self.ui_service = UiService(self)
         self.help_service = HelpService()
         self.lsp_service = LSPService(self)
         self.variables_service = VariablesService(self)

extensions/positron-python/python_files/positron/positron_ipykernel/tests/test_ui.py

@@ -123,6 +123,25 @@ def test_open_editor(ui_service: UiService, ui_comm: DummyComm) -> None:
     ]
 
 
+def test_is_module_loaded(ui_comm: DummyComm) -> None:
+    """
+    Test the `isModuleLoaded` RPC method called from Positron.
+    """
+    module = "fallingStars"
+    msg = json_rpc_request(
+        "call_method",
+        {
+            "method": "isModuleLoaded",
+            "params": [module],
+        },
+        comm_id="dummy_comm_id",
+    )
+    ui_comm.handle_msg(msg)
+
+    # Check that the response is sent, with a result of False.
+    assert ui_comm.messages == [json_rpc_response(False)]
+
+
 def test_clear_console(ui_service: UiService, ui_comm: DummyComm) -> None:
     ui_service.clear_console()
 

extensions/positron-python/python_files/positron/positron_ipykernel/ui.py

@@ -9,7 +9,7 @@
 import sys
 import webbrowser
 from pathlib import Path
-from typing import Callable, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Union
 from urllib.parse import urlparse
 
 from comm.base_comm import BaseComm
@@ -29,6 +29,9 @@
 )
 from .utils import JsonData, JsonRecord, alias_home, is_local_html_file
 
+if TYPE_CHECKING:
+    from .positron_ipkernel import PositronIPyKernel
+
 logger = logging.getLogger(__name__)
 
 _localhosts = [
@@ -51,7 +54,16 @@ class _InvalidParamsError(Exception):
     pass
 
 
-def _set_console_width(params: List[JsonData]) -> None:
+def _is_module_loaded(kernel: "PositronIPyKernel", params: List[JsonData]) -> bool:
+    if not (isinstance(params, list) and len(params) == 1 and isinstance(params[0], str)):
+        raise _InvalidParamsError(f"Expected a module name, got: {params}")
+    # Consider: this is not a perfect check for a couple of reasons:
+    # 1. The module could be loaded under a different name
+    # 2. The user may have a variable with the same name as the module
+    return params[0] in kernel.shell.user_ns.keys()
+
+
+def _set_console_width(kernel: "PositronIPyKernel", params: List[JsonData]) -> None:
     if not (isinstance(params, list) and len(params) == 1 and isinstance(params[0], int)):
         raise _InvalidParamsError(f"Expected an integer width, got: {params}")
 
@@ -79,8 +91,9 @@ def _set_console_width(params: List[JsonData]) -> None:
         torch_.set_printoptions(linewidth=width)
 
 
-_RPC_METHODS: Dict[str, Callable[[List[JsonData]], JsonData]] = {
+_RPC_METHODS: Dict[str, Callable[["PositronIPyKernel", List[JsonData]], Optional[JsonData]]] = {
     "setConsoleWidth": _set_console_width,
+    "isModuleLoaded": _is_module_loaded,
 }
 
 
@@ -90,7 +103,9 @@ class UiService:
     Used for communication with the frontend, unscoped to any particular view.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, kernel: "PositronIPyKernel") -> None:
+        self.kernel = kernel
+
         self._comm: Optional[PositronComm] = None
 
         self._working_directory: Optional[Path] = None
@@ -157,7 +172,7 @@ def _call_method(self, rpc_request: CallMethodParams) -> None:
             return logger.warning(f"Invalid frontend RPC request method: {rpc_request.method}")
 
         try:
-            result = func(rpc_request.params)
+            result = func(self.kernel, rpc_request.params)
         except _InvalidParamsError as exception:
             return logger.warning(
                 f"Invalid frontend RPC request params for method '{rpc_request.method}'. {exception}"

extensions/positron-python/src/client/positron/session.ts

@@ -203,6 +203,34 @@ export class PythonRuntimeSession implements positron.LanguageRuntimeSession, vs
         }
     }
 
+    async setWorkingDirectory(dir: string): Promise<void> {
+        if (this._kernel) {
+            // Check to see if the 'os' module is available in the kernel
+            const loaded = await this._kernel.callMethod('isModuleLoaded', 'os');
+            let code = '';
+            if (!loaded) {
+                code = 'import os; ';
+            }
+            // Escape backslashes in the directory path
+            dir = dir.replace(/\\/g, '\\\\');
+
+            // Escape single quotes in the directory path
+            dir = dir.replace(/'/g, "\\'");
+
+            // Set the working directory
+            code += `os.chdir('${dir}')`;
+
+            this._kernel.execute(
+                code,
+                createUniqueId(),
+                positron.RuntimeCodeExecutionMode.Interactive,
+                positron.RuntimeErrorBehavior.Continue,
+            );
+        } else {
+            throw new Error(`Cannot set working directory to ${dir}; kernel not started`);
+        }
+    }
+
     private async _installIpykernel(): Promise<void> {
         // Get the installer service
         const installer = this.serviceContainer.get<IInstaller>(IInstaller);
@@ -605,6 +633,10 @@ export class PythonRuntimeSession implements positron.LanguageRuntimeSession, vs
     }
 }
 
+export function createUniqueId(): string {
+    return Math.floor(Math.random() * 0x100000000).toString(16);
+}
+
 export function createJupyterKernelExtra(): undefined {
     // TODO: Implement and include startup hooks for the Python runtime.
     // return {

extensions/positron-r/src/session.ts

@@ -230,6 +230,29 @@ export class RSession implements positron.LanguageRuntimeSession, vscode.Disposa
 		}
 	}
 
+	/**
+	 * Sets the working directory for the runtime.
+	 *
+	 * @param dir The working directory to set.
+	 */
+	async setWorkingDirectory(dir: string): Promise<void> {
+		if (this._kernel) {
+			// Escape any backslashes in the directory path
+			dir = dir.replace(/\\/g, '\\\\');
+
+			// Escape any quotes in the directory path
+			dir = dir.replace(/"/g, '\\"');
+
+			// Tell the kernel to change the working directory
+			this._kernel.execute(`setwd("${dir}")`,
+				randomUUID(),
+				positron.RuntimeCodeExecutionMode.Interactive,
+				positron.RuntimeErrorBehavior.Continue);
+		} else {
+			throw new Error(`Cannot change to ${dir}; kernel not started`);
+		}
+	}
+
 	async start(): Promise<positron.LanguageRuntimeInfo> {
 		if (!this._kernel) {
 			this._kernel = await this.createKernel();

extensions/positron-reticulate/src/extension.ts

@@ -471,6 +471,10 @@ class ReticulateRuntimeSession implements positron.LanguageRuntimeSession {
 		return this.pythonSession.replyToPrompt(id, reply);
 	}
 
+	public setWorkingDirectory(dir: string): Thenable<void> {
+		return this.pythonSession.setWorkingDirectory(dir);
+	}
+
 	public start() {
 		return this.pythonSession.start();
 	}

extensions/positron-supervisor/src/KallichoreSession.ts

@@ -664,6 +664,19 @@ export class KallichoreSession implements JupyterLanguageRuntimeSession {
 		this.sendCommand(reply);
 	}
 
+	/**
+	 * Set the working directory for the kernel. This is a stub implementation since Jupyter
+	 * doesn't have a concept of a working directory.
+	 *
+	 * @param workingDirectory The working directory to set
+	 * @returns Nothing
+	 * @throws An error message indicating that this method is not implemented
+	 */
+	setWorkingDirectory(workingDirectory: string): Promise<void> {
+		return Promise.reject(
+			`Cannot change working directory to ${workingDirectory} (not implemented)`);
+	}
+
 	/**
 	 * Restores an existing session from the server.
 	 *

extensions/positron-zed/src/positronZedLanguageRuntime.ts

@@ -1072,6 +1072,16 @@ export class PositronZedRuntimeSession implements positron.LanguageRuntimeSessio
 		throw new Error('Method not implemented.');
 	}
 
+	/**
+	 * Set the working directory for the kernel.
+	 *
+	 * @param workingDirectory The working directory to set
+	 */
+	public setWorkingDirectory(workingDirectory: string): Promise<void> {
+		this._ui?.changeDirectory(workingDirectory);
+		return Promise.resolve();
+	}
+
 	/**
 	 * Starts the runtime; returns a Thenable that resolves with information about the runtime.
 	 * @returns A Thenable that resolves with information about the runtime