pick where code blocks without existing code uri are applied (microsoft#239208)

Author: aeschli

src/vs/workbench/contrib/chat/browser/actions/chatCodeblockActions.ts

@@ -108,7 +108,7 @@ export class CodeBlockActionRendering extends Disposable implements IWorkbenchCo
 					const context = this._context;
 					if (isCodeBlockActionContext(context) && context.codemapperUri) {
 						const label = labelService.getUriLabel(context.codemapperUri, { relative: true });
-						return localize('interactive.applyInEditorWithURL.label', "Apply in {0}", label);
+						return localize('interactive.applyInEditorWithURL.label', "Apply to {0}", label);
 					}
 					return super.getTooltip();
 				}

src/vs/workbench/contrib/chat/browser/actions/codeBlockOperations.ts

@@ -32,6 +32,8 @@ import { ICodeMapperCodeBlock, ICodeMapperRequest, ICodeMapperResponse, ICodeMap
 import { ChatUserAction, IChatService } from '../../common/chatService.js';
 import { isResponseVM } from '../../common/chatViewModel.js';
 import { ICodeBlockActionContext } from '../codeBlockPart.js';
+import { IQuickInputService } from '../../../../../platform/quickinput/common/quickInput.js';
+import { ILabelService } from '../../../../../platform/label/common/label.js';
 
 export class InsertCodeBlockOperation {
 	constructor(
@@ -104,48 +106,49 @@ export class ApplyCodeBlockOperation {
 	constructor(
 		@IEditorService private readonly editorService: IEditorService,
 		@ITextFileService private readonly textFileService: ITextFileService,
-		@ICodeEditorService private readonly codeEditorService: ICodeEditorService,
 		@IChatService private readonly chatService: IChatService,
 		@ILanguageService private readonly languageService: ILanguageService,
 		@IFileService private readonly fileService: IFileService,
 		@IDialogService private readonly dialogService: IDialogService,
 		@ILogService private readonly logService: ILogService,
 		@ICodeMapperService private readonly codeMapperService: ICodeMapperService,
-		@IProgressService private readonly progressService: IProgressService
+		@IProgressService private readonly progressService: IProgressService,
+		@IQuickInputService private readonly quickInputService: IQuickInputService,
+		@ILabelService private readonly labelService: ILabelService,
 	) {
 	}
 
 	public async run(context: ICodeBlockActionContext): Promise<void> {
 		let activeEditorControl = getEditableActiveCodeEditor(this.editorService);
 
-		if (context.codemapperUri && !isEqual(activeEditorControl?.getModel().uri, context.codemapperUri)) {
-			// If the code block is from a code mapper, first reveal the target file
-			try {
-				// If the file doesn't exist yet, create it
-				if (!(await this.fileService.exists(context.codemapperUri))) {
-					// TODO: try to find the file in the workspace
+		const codemapperUri = await this.evaluateURIToUse(context.codemapperUri, activeEditorControl);
+		if (!codemapperUri) {
+			return;
+		}
 
-					await this.fileService.writeFile(context.codemapperUri, VSBuffer.fromString(''));
-				}
-				await this.editorService.openEditor({ resource: context.codemapperUri });
+		if (codemapperUri && !isEqual(activeEditorControl?.getModel().uri, codemapperUri)) {
+			// reveal the target file
+			try {
+				await this.editorService.openEditor({ resource: codemapperUri });
 
 				activeEditorControl = getEditableActiveCodeEditor(this.editorService);
 				if (activeEditorControl) {
 					this.tryToRevealCodeBlock(activeEditorControl, context.code);
 				}
 			} catch (e) {
-				this.logService.info('[ApplyCodeBlockOperation] error opening code mapper file', context.codemapperUri, e);
+				this.logService.info('[ApplyCodeBlockOperation] error opening code mapper file', codemapperUri, e);
+				return;
 			}
 		}
 
 		let result: IComputeEditsResult | undefined = undefined;
 
 		if (activeEditorControl) {
-			result = await this.handleTextEditor(activeEditorControl, context);
+			result = await this.handleTextEditor(activeEditorControl, context.code);
 		} else {
 			const activeNotebookEditor = getActiveNotebookEditor(this.editorService);
 			if (activeNotebookEditor) {
-				result = await this.handleNotebookEditor(activeNotebookEditor, context);
+				result = await this.handleNotebookEditor(activeNotebookEditor, context.code);
 			} else {
 				this.notify(localize('applyCodeBlock.noActiveEditor', "To apply this code block, open a code or notebook editor."));
 			}
@@ -159,57 +162,98 @@ export class ApplyCodeBlockOperation {
 		});
 	}
 
-	private async handleNotebookEditor(notebookEditor: IActiveNotebookEditor, codeBlockContext: ICodeBlockActionContext): Promise<IComputeEditsResult | undefined> {
+	private async evaluateURIToUse(resource: URI | undefined, activeEditorControl: IActiveCodeEditor | undefined): Promise<URI | undefined> {
+		if (resource && await this.fileService.exists(resource)) {
+			return resource;
+		}
+
+		const activeEditorOption = activeEditorControl?.getModel().uri ? { label: localize('activeEditor', "Active editor '{0}'", this.labelService.getUriLabel(activeEditorControl.getModel().uri, { relative: true })), id: 'activeEditor' } : undefined;
+		const untitledEditorOption = { label: localize('newUntitledFile', "New untitled editor"), id: 'newUntitledFile' };
+
+		const options = [];
+		if (resource) {
+			// code block had an URI, but it doesn't exist
+			options.push({ label: localize('createFile', "New file '{0}'", this.labelService.getUriLabel(resource, { relative: true })), id: 'createFile' });
+			options.push(untitledEditorOption);
+			if (activeEditorOption) {
+				options.push(activeEditorOption);
+			}
+		} else {
+			// code block had no URI
+			if (activeEditorOption) {
+				options.push(activeEditorOption);
+			}
+			options.push(untitledEditorOption);
+		}
+
+		const selected = options.length > 1 ? await this.quickInputService.pick(options, { placeHolder: localize('selectOption', "Select where to apply the code block") }) : options[0];
+		if (selected) {
+			switch (selected.id) {
+				case 'createFile':
+					if (resource) {
+						try {
+							await this.fileService.writeFile(resource, VSBuffer.fromString(''));
+						} catch (error) {
+							this.notify(localize('applyCodeBlock.fileWriteError', "Failed to create file: {0}", error.message));
+							return URI.from({ scheme: 'untitled', path: resource.path });
+						}
+					}
+					return resource;
+				case 'newUntitledFile':
+					return URI.from({ scheme: 'untitled', path: resource ? resource.path : 'Untitled-1' });
+				case 'activeEditor':
+					return activeEditorControl?.getModel().uri;
+			}
+		}
+		return undefined;
+	}
+
+	private async handleNotebookEditor(notebookEditor: IActiveNotebookEditor, code: string): Promise<IComputeEditsResult | undefined> {
 		if (notebookEditor.isReadOnly) {
 			this.notify(localize('applyCodeBlock.readonlyNotebook', "Cannot apply code block to read-only notebook editor."));
 			return undefined;
 		}
 		const focusRange = notebookEditor.getFocus();
 		const next = Math.max(focusRange.end - 1, 0);
-		insertCell(this.languageService, notebookEditor, next, CellKind.Code, 'below', codeBlockContext.code, true);
+		insertCell(this.languageService, notebookEditor, next, CellKind.Code, 'below', code, true);
 		return undefined;
 	}
 
-	private async handleTextEditor(codeEditor: IActiveCodeEditor, codeBlockContext: ICodeBlockActionContext): Promise<IComputeEditsResult | undefined> {
+	private async handleTextEditor(codeEditor: IActiveCodeEditor, code: string): Promise<IComputeEditsResult | undefined> {
 		const activeModel = codeEditor.getModel();
 		if (isReadOnly(activeModel, this.textFileService)) {
 			this.notify(localize('applyCodeBlock.readonly', "Cannot apply code block to read-only file."));
 			return undefined;
 		}
 
-		const resource = codeBlockContext.codemapperUri ?? activeModel.uri;
-		const codeBlock = { code: codeBlockContext.code, resource, markdownBeforeBlock: undefined };
+		const codeBlock = { code, resource: activeModel.uri, markdownBeforeBlock: undefined };
 
 		const codeMapper = this.codeMapperService.providers[0]?.displayName;
 		if (!codeMapper) {
 			this.notify(localize('applyCodeBlock.noCodeMapper', "No code mapper available."));
 			return undefined;
 		}
 		let editsProposed = false;
-
-		const editorToApply = await this.codeEditorService.openCodeEditor({ resource }, codeEditor);
-		if (editorToApply && editorToApply.hasModel()) {
-
-			const cancellationTokenSource = new CancellationTokenSource();
-			try {
-				const iterable = await this.progressService.withProgress<AsyncIterable<TextEdit[]>>(
-					{ location: ProgressLocation.Notification, delay: 500, sticky: true, cancellable: true },
-					async progress => {
-						progress.report({ message: localize('applyCodeBlock.progress', "Applying code block using {0}...", codeMapper) });
-						const editsIterable = this.getEdits(codeBlock, cancellationTokenSource.token);
-						return await this.waitForFirstElement(editsIterable);
-					},
-					() => cancellationTokenSource.cancel()
-				);
-				editsProposed = await this.applyWithInlinePreview(iterable, editorToApply, cancellationTokenSource);
-			} catch (e) {
-				if (!isCancellationError(e)) {
-					this.notify(localize('applyCodeBlock.error', "Failed to apply code block: {0}", e.message));
-				}
-			} finally {
-				cancellationTokenSource.dispose();
+		const cancellationTokenSource = new CancellationTokenSource();
+		try {
+			const iterable = await this.progressService.withProgress<AsyncIterable<TextEdit[]>>(
+				{ location: ProgressLocation.Notification, delay: 500, sticky: true, cancellable: true },
+				async progress => {
+					progress.report({ message: localize('applyCodeBlock.progress', "Applying code block using {0}...", codeMapper) });
+					const editsIterable = this.getEdits(codeBlock, cancellationTokenSource.token);
+					return await this.waitForFirstElement(editsIterable);
+				},
+				() => cancellationTokenSource.cancel()
+			);
+			editsProposed = await this.applyWithInlinePreview(iterable, codeEditor, cancellationTokenSource);
+		} catch (e) {
+			if (!isCancellationError(e)) {
+				this.notify(localize('applyCodeBlock.error', "Failed to apply code block: {0}", e.message));
 			}
+		} finally {
+			cancellationTokenSource.dispose();
 		}
+
 		return {
 			editsProposed,
 			codeMapper