Improve resolveFilePath function to correctly handle URIs and file paths (#25632)

Fixes #25382

Author: karthiknadig

src/client/chat/utils.ts

@@ -19,21 +19,29 @@ import { JUPYTER_EXTENSION_ID, NotebookCellScheme } from '../common/constants';
 import { dirname, join } from 'path';
 import { resolveEnvironment, useEnvExtension } from '../envExt/api.internal';
 import { ErrorWithTelemetrySafeReason } from '../common/errors/errorUtils';
+import { getWorkspaceFolders } from '../common/vscodeApis/workspaceApis';
 
 export interface IResourceReference {
     resourcePath?: string;
 }
 
 export function resolveFilePath(filepath?: string): Uri | undefined {
     if (!filepath) {
-        return workspace.workspaceFolders ? workspace.workspaceFolders[0].uri : undefined;
+        const folders = getWorkspaceFolders() ?? [];
+        return folders.length > 0 ? folders[0].uri : undefined;
     }
-    // starts with a scheme
-    try {
-        return Uri.parse(filepath);
-    } catch (e) {
-        return Uri.file(filepath);
+    // Check if it's a URI with a scheme (contains "://")
+    // This handles schemes like "file://", "vscode-notebook://", etc.
+    // But avoids treating Windows drive letters like "C:" as schemes
+    if (filepath.includes('://')) {
+        try {
+            return Uri.parse(filepath);
+        } catch {
+            return Uri.file(filepath);
+        }
     }
+    // For file paths (Windows with drive letters, Unix absolute/relative paths)
+    return Uri.file(filepath);
 }
 
 /**

src/test/chat/utils.unit.test.ts

@@ -0,0 +1,248 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Uri, WorkspaceFolder } from 'vscode';
+import { resolveFilePath } from '../../client/chat/utils';
+import * as workspaceApis from '../../client/common/vscodeApis/workspaceApis';
+
+suite('Chat Utils - resolveFilePath()', () => {
+    let getWorkspaceFoldersStub: sinon.SinonStub;
+
+    setup(() => {
+        getWorkspaceFoldersStub = sinon.stub(workspaceApis, 'getWorkspaceFolders');
+        getWorkspaceFoldersStub.returns([]);
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    suite('When filepath is undefined or empty', () => {
+        test('Should return first workspace folder URI when workspace folders exist', () => {
+            const expectedUri = Uri.file('/test/workspace');
+            const mockFolder: WorkspaceFolder = {
+                uri: expectedUri,
+                name: 'test',
+                index: 0,
+            };
+            getWorkspaceFoldersStub.returns([mockFolder]);
+
+            const result = resolveFilePath(undefined);
+
+            expect(result?.toString()).to.equal(expectedUri.toString());
+        });
+
+        test('Should return first folder when multiple workspace folders exist', () => {
+            const firstUri = Uri.file('/first/workspace');
+            const secondUri = Uri.file('/second/workspace');
+            const mockFolders: WorkspaceFolder[] = [
+                { uri: firstUri, name: 'first', index: 0 },
+                { uri: secondUri, name: 'second', index: 1 },
+            ];
+            getWorkspaceFoldersStub.returns(mockFolders);
+
+            const result = resolveFilePath(undefined);
+
+            expect(result?.toString()).to.equal(firstUri.toString());
+        });
+
+        test('Should return undefined when no workspace folders exist', () => {
+            getWorkspaceFoldersStub.returns(undefined);
+
+            const result = resolveFilePath(undefined);
+
+            expect(result).to.be.undefined;
+        });
+
+        test('Should return undefined when workspace folders is empty array', () => {
+            getWorkspaceFoldersStub.returns([]);
+
+            const result = resolveFilePath(undefined);
+
+            expect(result).to.be.undefined;
+        });
+
+        test('Should return undefined for empty string when no workspace folders', () => {
+            getWorkspaceFoldersStub.returns(undefined);
+
+            const result = resolveFilePath('');
+
+            expect(result).to.be.undefined;
+        });
+    });
+
+    suite('Windows file paths', () => {
+        test('Should handle Windows path with lowercase drive letter', () => {
+            const filepath = 'c:\\GIT\\tests\\simple-python-app';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+            // Uri.file normalizes drive letters to lowercase
+            expect(result?.fsPath.toLowerCase()).to.include('git');
+        });
+
+        test('Should handle Windows path with uppercase drive letter', () => {
+            const filepath = 'C:\\Users\\test\\project';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+            expect(result?.fsPath.toLowerCase()).to.include('users');
+        });
+
+        test('Should handle Windows path with forward slashes', () => {
+            const filepath = 'C:/Users/test/project';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+    });
+
+    suite('Unix file paths', () => {
+        test('Should handle Unix absolute path', () => {
+            const filepath = '/home/user/projects/myapp';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+            expect(result?.path).to.include('/home/user/projects/myapp');
+        });
+
+        test('Should handle Unix root path', () => {
+            const filepath = '/';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+    });
+
+    suite('Relative paths', () => {
+        test('Should handle relative path with dot prefix', () => {
+            const filepath = './src/main.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should handle relative path without prefix', () => {
+            const filepath = 'src/main.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should handle parent directory reference', () => {
+            const filepath = '../other-project/file.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+    });
+
+    suite('URI schemes', () => {
+        test('Should handle file:// URI scheme', () => {
+            const filepath = 'file:///home/user/test.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+            expect(result?.path).to.include('/home/user/test.py');
+        });
+
+        test('Should handle vscode-notebook:// URI scheme', () => {
+            const filepath = 'vscode-notebook://jupyter/notebook.ipynb';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('vscode-notebook');
+        });
+
+        test('Should handle untitled: URI scheme without double slash as file path', () => {
+            const filepath = 'untitled:Untitled-1';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            // untitled: doesn't have ://, so it will be treated as a file path
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should handle https:// URI scheme', () => {
+            const filepath = 'https://example.com/path';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('https');
+        });
+
+        test('Should handle vscode-vfs:// URI scheme', () => {
+            const filepath = 'vscode-vfs://github/microsoft/vscode/file.ts';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('vscode-vfs');
+        });
+    });
+
+    suite('Edge cases', () => {
+        test('Should handle path with spaces', () => {
+            const filepath = '/home/user/my project/file.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should handle path with special characters', () => {
+            const filepath = '/home/user/project-name_v2/file.py';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should not treat Windows drive letter colon as URI scheme', () => {
+            // Windows path should not be confused with a URI scheme
+            const filepath = 'd:\\projects\\test';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+
+        test('Should not treat single colon as URI scheme', () => {
+            // A path with a colon but not :// should be treated as a file
+            const filepath = 'c:somepath';
+
+            const result = resolveFilePath(filepath);
+
+            expect(result).to.not.be.undefined;
+            expect(result?.scheme).to.equal('file');
+        });
+    });
+});