Support settings of custom project path in Kedro Extension

bundled/tool/lsp_server.py

@@ -102,7 +102,7 @@ def _set_project_with_workspace(self):
         try:
             self.workspace_settings = next(iter(WORKSPACE_SETTINGS.values()))
             root_path = pathlib.Path(
-                self.workspace.root_path
+                self.workspace_settings.get("kedroProjectPath") or self.workspace.root_path
             )  # todo: From language server, can we get it from client initialise response instead?
             project_metadata = bootstrap_project(root_path)
             env = None
@@ -489,6 +489,7 @@ def _get_global_defaults():
         "importStrategy": GLOBAL_SETTINGS.get("importStrategy", "useBundled"),
         "showNotifications": GLOBAL_SETTINGS.get("showNotifications", "off"),
         "environment": GLOBAL_SETTINGS.get("environment", ""),
+        "kedroProjectPath": GLOBAL_SETTINGS.get("kedroProjectPath", ""),
     }
 
 
@@ -578,7 +579,9 @@ def get_project_data_from_viz(lsClient):
 
     data = None
     try:
-        load_and_populate_data(Path.cwd())
+        workspace_settings = next(iter(WORKSPACE_SETTINGS.values()))
+        kedro_project_path = Path(workspace_settings.get("kedroProjectPath")) or Path.cwd()
+        load_and_populate_data(kedro_project_path)
         data = get_kedro_project_json_data()
         return data
     except Exception as e:

package.json

@@ -139,6 +139,12 @@
                     ],
                     "scope": "machine",
                     "type": "string"
+                },
+                "kedro.kedroProjectPath": {
+                    "default": "",
+                    "description": "Custom path to Kedro project root directory. Please add absolute path to your Kedro project root directory.",
+                    "scope": "resource",
+                    "type": "string"
                 }
             }
         },
@@ -167,6 +173,11 @@
                 "command": "kedro.showOutputChannel",
                 "category": "kedro",
                 "title": "Show logs"
+            },
+            {
+                "command": "kedro.kedroProjectPath",
+                "title": "Kedro: Set Project Path", 
+                "category": "kedro"
             }
         ]
     },

src/common/commands.ts

@@ -1,27 +1,90 @@
 import * as fs from 'fs';
-import { QuickPickItem, window } from 'vscode';
+import * as path from 'path';
+import { QuickPickItem, window, Uri } from 'vscode';
 import * as vscode from 'vscode';
 
 import { getWorkspaceFolders } from './vscodeapi';
-import { LanguageClient, LanguageClientOptions, ServerOptions, State, integer } from 'vscode-languageclient/node';
+import { LanguageClient, State } from 'vscode-languageclient/node';
+import { isKedroProject } from './utilities';
 export async function selectEnvironment() {
-    let workspaces = getWorkspaceFolders();
-    const root_dir = workspaces[0].uri.fsPath; // Only pick the first workspace
-    const confDir = `${root_dir}/conf`;
+    const config = vscode.workspace.getConfiguration('kedro');
+    let kedroProjectPath = config.get<string>('kedroProjectPath');
+    let kedroProjectRootDir: string | undefined = undefined;
+
+    if (kedroProjectPath) {
+        kedroProjectRootDir = kedroProjectPath;
+    } else {
+        let workspaces = getWorkspaceFolders();
+        kedroProjectRootDir = workspaces[0].uri.fsPath; // Only pick the first workspace
+    }
+
+    const confDir = `${kedroProjectRootDir}/conf`;
     // Iterate the `conf` directory to get folder names
     const directories = fs
         .readdirSync(confDir, { withFileTypes: true })
         .filter((dirent) => dirent.isDirectory())
         .map((dirent) => dirent.name);
 
-    const envs: QuickPickItem[] = directories.filter(dir => dir !== 'base').map((label) => ({ label }));
+    const envs: QuickPickItem[] = directories.filter((dir) => dir !== 'base').map((label) => ({ label }));
 
     const result = await window.showQuickPick(envs, {
         placeHolder: 'Select Kedro runtime environment',
     });
 
     return result;
 }
+
+export async function setKedroProjectPath() {
+    const result = await vscode.window.showInputBox({
+        placeHolder: 'Enter the Kedro Project Root Directory',
+        prompt: 'Please provide the path to the Kedro project root directory',
+        validateInput: async (value) => {
+            if (!value) {
+                return 'Path cannot be empty';
+            }
+            // Verify if path exists and is a Kedro project
+            if (!(await isKedroProject(value))) {
+                return 'Invalid Kedro project path. Please ensure it contains pyproject.toml';
+            }
+            return null;
+        },
+    });
+
+    if (result) {
+        // Create URI from the path
+        const uri = vscode.Uri.file(result);
+
+        // Get current workspace folders
+        const currentFolders = vscode.workspace.workspaceFolders || [];
+
+        // Check if the entered path is already part of any workspace folder
+        const isPartOfWorkspace = currentFolders.some((folder) => {
+            const folderPath = folder.uri.fsPath;
+            return result.startsWith(folderPath) || folderPath.startsWith(result);
+        });
+
+        // If path is not part of workspace, add it as a new workspace folder
+        if (!isPartOfWorkspace) {
+            // Add new folder to workspace
+            const success = await vscode.workspace.updateWorkspaceFolders(
+                currentFolders.length,
+                0,
+                { uri: uri, name: path.basename(result) }, // New folder to add
+            );
+
+            if (!success) {
+                vscode.window.showErrorMessage('Failed to add folder to workspace');
+                return;
+            }
+        }
+
+        // Update kedro configuration
+        const config = vscode.workspace.getConfiguration('kedro');
+        await config.update('kedroProjectPath', result, vscode.ConfigurationTarget.Workspace);
+        vscode.window.showInformationMessage('Kedro project path updated successfully');
+    }
+}
+
 let logger: vscode.LogOutputChannel;
 
 /**
@@ -113,4 +176,3 @@ export async function executeGetProjectDataCommand(lsClient: LanguageClient | un
     const result = await vscode.commands.executeCommand(commandName);
     return result;
 }
-

src/common/server.ts

@@ -28,7 +28,9 @@ async function createServer(
     environment?: string,
 ): Promise<LanguageClient> {
     const command = settings.interpreter[0];
-    const cwd = settings.cwd;
+
+    // Use kedroProjectPath if set, otherwise fallback to settings.cwd
+    const cwd = settings.kedroProjectPath || settings.cwd;
 
     // Set debugger path needed for debugging python code.
     const newEnv = { ...process.env };

src/common/settings.ts

@@ -15,6 +15,7 @@ export interface ISettings {
     showNotifications: string;
     isExperimental: string;
     environment: string;
+    kedroProjectPath: string;
 }
 
 export function getExtensionSettings(namespace: string, includeInterpreter?: boolean): Promise<ISettings[]> {
@@ -73,6 +74,7 @@ export async function getWorkspaceSettings(
         showNotifications: config.get<string>(`showNotifications`) ?? 'off',
         isExperimental: config.get<string>(`isExperimental`) ?? 'yes',
         environment: config.get<string>(`environment`) ?? '',
+        kedroProjectPath: config.get<string>(`kedroProjectPath`) ?? '',
     };
     return workspaceSetting;
 }
@@ -103,6 +105,7 @@ export async function getGlobalSettings(namespace: string, includeInterpreter?:
         showNotifications: getGlobalValue<string>(config, 'showNotifications', 'off'),
         isExperimental: getGlobalValue<string>(config, 'isExperimental', 'yes'),
         environment: getGlobalValue<string>(config, 'environment', ''),
+        kedroProjectPath: getGlobalValue<string>(config, 'kedroProjectPath', ''),
     };
     return setting;
 }
@@ -115,6 +118,7 @@ export function checkIfConfigurationChanged(e: ConfigurationChangeEvent, namespa
         `${namespace}.importStrategy`,
         `${namespace}.showNotifications`,
         `${namespace}.environment`,
+        `${namespace}.kedroProjectPath`,
     ];
     const changed = settings.map((s) => e.affectsConfiguration(s));
     return changed.includes(true);

src/common/utilities.ts

@@ -43,6 +43,17 @@ export function getLSClientTraceLevel(channelLogLevel: LogLevel, globalLogLevel:
 }
 
 export async function getProjectRoot(): Promise<WorkspaceFolder> {
+    const config = vscode.workspace.getConfiguration('kedro');
+    let kedroProjectPath = config.get<string>('kedroProjectPath');
+
+    if (kedroProjectPath && kedroProjectPath.trim()) {
+        return {
+            uri: Uri.file(kedroProjectPath),
+            name: path.basename(kedroProjectPath),
+            index: 0,
+        };
+    }
+
     const workspaces: readonly WorkspaceFolder[] = getWorkspaceFolders();
     if (workspaces.length === 0) {
         return {
@@ -132,8 +143,11 @@ export async function checkKedroViz(context: vscode.ExtensionContext): Promise<b
 
 export async function checkKedroProjectConsent(context: vscode.ExtensionContext): Promise<Boolean> {
     const pathToScript = 'bundled/tool/check_consent.py';
+    const config = vscode.workspace.getConfiguration('kedro');
+    let rootDir = config.get<string>('kedroProjectPath') || EXTENSION_ROOT_DIR;
+
     try {
-        const stdout = await callPythonScript(pathToScript, EXTENSION_ROOT_DIR, context);
+        const stdout = await callPythonScript(pathToScript, rootDir, context);
         const telemetryResult = parseTelemetryConsent(stdout);
 
         // Check if the script output contains the success message
@@ -177,26 +191,37 @@ export async function updateKedroVizPanel(lsClient: LanguageClient | undefined):
     KedroVizPanel.currentPanel?.updateData(projectData);
 }
 
-export async function isKedroProject(): Promise<boolean> {
+export async function isKedroProject(kedroProjectPath?: string): Promise<boolean> {
+    if (kedroProjectPath && kedroProjectPath.trim()) {
+        return await checkPyprojectToml(kedroProjectPath);
+    }
+
+    // No specific path: check all workspace folders
     const folders = getWorkspaceFolders();
     if (!folders || folders.length === 0) {
         return false;
     }
 
-    // Check all workspace folders
     for (const folder of folders) {
-        const pyprojectPath = path.join(folder.uri.fsPath, 'pyproject.toml');
-        try {
-            const content = await fs.readFile(pyprojectPath, 'utf8');
-            if (content.includes('[tool.kedro]')) {
-                traceLog(`Kedro project detected in folder: ${folder.uri.fsPath}`);
-                return true;
-            }
-        } catch (error) {
-            // Continue if we can't find/read files
-            traceError(`Error reading ${pyprojectPath}: ${error}`);
-            continue;
+        if (await checkPyprojectToml(folder.uri.fsPath)) {
+            return true;
         }
     }
+
+    return false;
+}
+
+async function checkPyprojectToml(projectPath: string): Promise<boolean> {
+    const pyprojectPath = path.join(projectPath, 'pyproject.toml');
+    try {
+        const content = await fs.readFile(pyprojectPath, 'utf8');
+        if (content.includes('[tool.kedro]')) {
+            traceLog(`Kedro project detected at ${projectPath}`);
+            return true;
+        }
+    } catch (error) {
+        // Only log the error if needed, otherwise we silently fail
+        traceError(`Error reading ${pyprojectPath}: ${error}`);
+    }
     return false;
 }