Merge pull request microsoft#166326 from microsoft/merogge/quick-fix-api

add terminal quick fix API

Author: Tyriar

src/vs/platform/actionWidget/browser/actionList.ts

@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as dom from 'vs/base/browser/dom';
+import { HighlightedLabel } from 'vs/base/browser/ui/highlightedlabel/highlightedLabel';
 import { KeybindingLabel } from 'vs/base/browser/ui/keybindingLabel/keybindingLabel';
 import { IListEvent, IListMouseEvent, IListRenderer, IListVirtualDelegate } from 'vs/base/browser/ui/list/list';
 import { List } from 'vs/base/browser/ui/list/listWidget';
@@ -29,6 +30,7 @@ export interface IListMenuItem<T extends IActionItem> {
 	group?: { kind?: any; icon?: { codicon: Codicon; color?: string }; title: string };
 	disabled?: boolean;
 	label?: string;
+	description?: string;
 }
 
 interface IActionMenuTemplateData {
@@ -131,6 +133,11 @@ class ActionItemRenderer<T extends IListMenuItem<IActionItem>> implements IListR
 		} else {
 			data.container.title = '';
 		}
+		if (element.description) {
+			const label = new HighlightedLabel(dom.append(data.container, dom.$('span.label-description')));
+			label.element.classList.add('action-list-description');
+			label.set(element.description);
+		}
 	}
 
 	disposeTemplate(_templateData: IActionMenuTemplateData): void {

src/vs/platform/actionWidget/browser/actionWidget.css

@@ -3,6 +3,13 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+.action-list-description {
+	opacity: .7;
+	margin-left: 0.5em;
+	font-size: .9em;
+	white-space: pre;
+}
+
 .action-widget {
 	font-size: 13px;
 	border-radius: 0;

src/vs/platform/terminal/common/capabilities/capabilities.ts

@@ -6,6 +6,7 @@
 import { Event } from 'vs/base/common/event';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { ReplayEntry } from 'vs/platform/terminal/common/terminalProcess';
+import { ITerminalOutputMatch, ITerminalOutputMatcher } from 'vs/platform/terminal/common/xterm/terminalQuickFix';
 
 interface IEvent<T, U = void> {
 	(listener: (arg1: T, arg2: U) => any): IDisposable;
@@ -220,36 +221,12 @@ export interface ITerminalCommand {
 	executedMarker?: IXtermMarker;
 	commandStartLineContent?: string;
 	markProperties?: IMarkProperties;
+	aliases?: string[][];
 	getOutput(): string | undefined;
-	getOutputMatch(outputMatcher: ITerminalOutputMatcher): RegExpMatchArray | undefined;
+	getOutputMatch(outputMatcher: ITerminalOutputMatcher): ITerminalOutputMatch | undefined;
 	hasOutput(): boolean;
 }
 
-
-/**
- * A matcher that runs on a sub-section of a terminal command's output
- */
-export interface ITerminalOutputMatcher {
-	/**
-	 * A string or regex to match against the unwrapped line. If this is a regex with the multiline
-	 * flag, it will scan an amount of lines equal to `\n` instances in the regex + 1.
-	 */
-	lineMatcher: string | RegExp;
-	/**
-	 * Which side of the output to anchor the {@link offset} and {@link length} against.
-	 */
-	anchor: 'top' | 'bottom';
-	/**
-	 * How far from either the top or the bottom of the butter to start matching against.
-	 */
-	offset: number;
-	/**
-	 * The number of rows to match against, this should be as small as possible for performance
-	 * reasons.
-	 */
-	length: number;
-}
-
 /**
  * A clone of the IMarker from xterm which cannot be imported from common
  */

src/vs/platform/terminal/common/capabilities/commandDetectionCapability.ts

@@ -7,7 +7,8 @@ import { timeout } from 'vs/base/common/async';
 import { debounce } from 'vs/base/common/decorators';
 import { Emitter } from 'vs/base/common/event';
 import { ILogService } from 'vs/platform/log/common/log';
-import { ICommandDetectionCapability, TerminalCapability, ITerminalCommand, IHandleCommandOptions, ICommandInvalidationRequest, CommandInvalidationReason, ISerializedCommand, ISerializedCommandDetectionCapability, ITerminalOutputMatcher } from 'vs/platform/terminal/common/capabilities/capabilities';
+import { ICommandDetectionCapability, TerminalCapability, ITerminalCommand, IHandleCommandOptions, ICommandInvalidationRequest, CommandInvalidationReason, ISerializedCommand, ISerializedCommandDetectionCapability } from 'vs/platform/terminal/common/capabilities/capabilities';
+import { ITerminalOutputMatch, ITerminalOutputMatcher } from 'vs/platform/terminal/common/xterm/terminalQuickFix';
 
 // Importing types is safe in any layer
 // eslint-disable-next-line local/code-import-patterns
@@ -559,7 +560,8 @@ export class CommandDetectionCapability implements ICommandDetectionCapability {
 				exitCode: e.exitCode,
 				commandStartLineContent: e.commandStartLineContent,
 				timestamp: e.timestamp,
-				markProperties: e.markProperties
+				markProperties: e.markProperties,
+				aliases: e.aliases
 			};
 		});
 		if (this._currentCommand.commandStartMarker) {
@@ -647,7 +649,7 @@ function getOutputForCommand(executedMarker: IMarker | undefined, endMarker: IMa
 	return output === '' ? undefined : output;
 }
 
-export function getOutputMatchForCommand(executedMarker: IMarker | undefined, endMarker: IMarker | undefined, buffer: IBuffer, cols: number, outputMatcher: ITerminalOutputMatcher): RegExpMatchArray | undefined {
+export function getOutputMatchForCommand(executedMarker: IMarker | undefined, endMarker: IMarker | undefined, buffer: IBuffer, cols: number, outputMatcher: ITerminalOutputMatcher): ITerminalOutputMatch | undefined {
 	if (!executedMarker || !endMarker) {
 		return undefined;
 	}
@@ -657,6 +659,7 @@ export function getOutputMatchForCommand(executedMarker: IMarker | undefined, en
 	const matcher = outputMatcher.lineMatcher;
 	const linesToCheck = typeof matcher === 'string' ? 1 : outputMatcher.length || countNewLines(matcher);
 	const lines: string[] = [];
+	let match: RegExpMatchArray | null | undefined;
 	if (outputMatcher.anchor === 'bottom') {
 		for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {
 			let wrappedLineStart = i;
@@ -669,9 +672,11 @@ export function getOutputMatchForCommand(executedMarker: IMarker | undefined, en
 			if (lines.length > linesToCheck) {
 				lines.pop();
 			}
-			const match = lines.join('\n').match(matcher);
-			if (match) {
-				return match;
+			if (!match) {
+				match = lines.join('\n').match(matcher);
+				if (!outputMatcher.multipleMatches && match) {
+					return { regexMatch: match };
+				}
 			}
 		}
 	} else {
@@ -686,17 +691,62 @@ export function getOutputMatchForCommand(executedMarker: IMarker | undefined, en
 			if (lines.length === linesToCheck) {
 				lines.shift();
 			}
-			if (outputMatcher) {
-				const match = lines.join('\n').match(matcher);
-				if (match) {
-					return match;
+			if (!match) {
+				match = lines.join('\n').match(matcher);
+				if (!outputMatcher.multipleMatches && match) {
+					return { regexMatch: match };
 				}
 			}
 		}
 	}
-	return undefined;
+	return match ? { regexMatch: match, outputLines: lines } : undefined;
+}
+
+export function getLinesForCommand(buffer: IBuffer, command: ITerminalCommand, cols: number, outputMatcher?: ITerminalOutputMatcher): string[] | undefined {
+	if (!outputMatcher) {
+		return undefined;
+	}
+	const executedMarker = command.executedMarker;
+	const endMarker = command.endMarker;
+	if (!executedMarker || !endMarker) {
+		throw new Error('No marker for command');
+	}
+	const startLine = executedMarker.line;
+	const endLine = endMarker.line;
+
+	const linesToCheck = outputMatcher.length;
+	const lines: string[] = [];
+	if (outputMatcher.anchor === 'bottom') {
+		for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {
+			let wrappedLineStart = i;
+			const wrappedLineEnd = i;
+			while (wrappedLineStart >= startLine && buffer.getLine(wrappedLineStart)?.isWrapped) {
+				wrappedLineStart--;
+			}
+			i = wrappedLineStart;
+			lines.unshift(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols));
+			if (lines.length > linesToCheck) {
+				lines.pop();
+			}
+		}
+	} else {
+		for (let i = startLine + (outputMatcher.offset || 0); i < endLine; i++) {
+			const wrappedLineStart = i;
+			let wrappedLineEnd = i;
+			while (wrappedLineEnd + 1 < endLine && buffer.getLine(wrappedLineEnd + 1)?.isWrapped) {
+				wrappedLineEnd++;
+			}
+			i = wrappedLineEnd;
+			lines.push(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols));
+			if (lines.length === linesToCheck) {
+				lines.shift();
+			}
+		}
+	}
+	return lines;
 }
 
+
 function getXtermLineContent(buffer: IBuffer, lineStart: number, lineEnd: number, cols: number): string {
 	// Cap the maximum number of lines generated to prevent potential performance problems. This is
 	// more of a sanity check as the wrapped line should already be trimmed down at this point.

src/vs/platform/terminal/common/terminal.ts

@@ -7,10 +7,12 @@ import { Event } from 'vs/base/common/event';
 import { IProcessEnvironment, OperatingSystem } from 'vs/base/common/platform';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
-import { IPtyHostProcessReplayEvent, ISerializedCommandDetectionCapability, ITerminalCapabilityStore, ITerminalOutputMatcher } from 'vs/platform/terminal/common/capabilities/capabilities';
+import { IPtyHostProcessReplayEvent, ISerializedCommandDetectionCapability, ITerminalCapabilityStore } from 'vs/platform/terminal/common/capabilities/capabilities';
 import { IGetTerminalLayoutInfoArgs, IProcessDetails, ISetTerminalLayoutInfoArgs } from 'vs/platform/terminal/common/terminalProcess';
 import { ThemeIcon } from 'vs/platform/theme/common/themeService';
 import { ISerializableEnvironmentVariableCollections } from 'vs/platform/terminal/common/environmentVariable';
+import { ITerminalCommandSelector } from 'vs/platform/terminal/common/xterm/terminalQuickFix';
+
 
 export const enum TerminalSettingPrefix {
 	Shell = 'terminal.integrated.shell.',
@@ -794,21 +796,6 @@ export interface ITerminalProfileSource extends IBaseUnresolvedTerminalProfile {
 	source: ProfileSource;
 }
 
-
-export interface ITerminalContributions {
-	profiles?: ITerminalProfileContribution[];
-	quickFixes?: ITerminalQuickFixContribution[];
-}
-
-export interface ITerminalQuickFixContribution {
-	id: string;
-	commandLineMatcher: string | RegExp;
-	outputMatcher: ITerminalOutputMatcher;
-	exitStatus?: boolean;
-	commandToRun?: string;
-	linkToOpen?: string;
-}
-
 export interface ITerminalProfileContribution {
 	title: string;
 	id: string;
@@ -820,10 +807,6 @@ export interface IExtensionTerminalProfile extends ITerminalProfileContribution
 	extensionIdentifier: string;
 }
 
-export interface IExtensionTerminalQuickFix extends ITerminalQuickFixContribution {
-	extensionIdentifier: string;
-}
-
 export type ITerminalProfileObject = ITerminalExecutable | ITerminalProfileSource | IExtensionTerminalProfile | null;
 
 export interface IShellIntegration {
@@ -835,6 +818,11 @@ export interface IShellIntegration {
 	deserialize(serialized: ISerializedCommandDetectionCapability): void;
 }
 
+export interface ITerminalContributions {
+	profiles?: ITerminalProfileContribution[];
+	quickFixes?: ITerminalCommandSelector[];
+}
+
 export const enum ShellIntegrationStatus {
 	/** No shell integration sequences have been encountered. */
 	Off,

src/vs/platform/terminal/common/xterm/terminalQuickFix.ts

@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+import { IAction } from 'vs/base/common/actions';
+import { CancellationToken } from 'vs/base/common/cancellation';
+import { UriComponents } from 'vs/base/common/uri';
+import { ITerminalCommand } from 'vs/platform/terminal/common/capabilities/capabilities';
+
+export interface ITerminalCommandSelector {
+	id: string;
+	commandLineMatcher: string | RegExp;
+	outputMatcher?: ITerminalOutputMatcher;
+	exitStatus: boolean;
+}
+
+
+export interface ITerminalQuickFixOptions {
+	type: 'internal' | 'resolved' | 'unresolved';
+	id: string;
+	commandLineMatcher: string | RegExp;
+	outputMatcher?: ITerminalOutputMatcher;
+	exitStatus: boolean;
+}
+
+export interface ITerminalQuickFix {
+	type: 'command' | 'opener';
+	id: string;
+	source: string;
+}
+
+export interface ITerminalQuickFixCommandAction extends ITerminalQuickFix {
+	type: 'command';
+	terminalCommand: string;
+	// TODO: Should this depend on whether alt is held?
+	addNewLine?: boolean;
+}
+export interface ITerminalQuickFixOpenerAction extends ITerminalQuickFix {
+	type: 'opener';
+	uri: UriComponents;
+}
+
+export interface ITerminalCommandSelector {
+	commandLineMatcher: string | RegExp;
+	outputMatcher?: ITerminalOutputMatcher;
+	exitStatus: boolean;
+}
+
+export type TerminalQuickFixActionInternal = IAction | ITerminalQuickFixCommandAction | ITerminalQuickFixOpenerAction;
+export type TerminalQuickFixCallback = (matchResult: ITerminalCommandMatchResult) => TerminalQuickFixActionInternal[] | TerminalQuickFixActionInternal | undefined;
+export type TerminalQuickFixCallbackExtension = (terminalCommand: ITerminalCommand, lines: string[] | undefined, option: ITerminalQuickFixOptions, token: CancellationToken) => Promise<ITerminalQuickFix[] | ITerminalQuickFix | undefined>;
+
+export interface ITerminalQuickFixProvider {
+	/**
+	 * Provides terminal quick fixes
+	 * @param commandMatchResult The command match result for which to provide quick fixes
+	 * @param token A cancellation token indicating the result is no longer needed
+	 * @return Terminal quick fix(es) if any
+	 */
+	provideTerminalQuickFixes(terminalCommand: ITerminalCommand, lines: string[] | undefined, option: ITerminalQuickFixOptions, token: CancellationToken): Promise<ITerminalQuickFix[] | ITerminalQuickFix | undefined>;
+}
+export interface ITerminalCommandMatchResult {
+	commandLine: string;
+	commandLineMatch: RegExpMatchArray;
+	outputMatch?: ITerminalOutputMatch;
+}
+
+export interface ITerminalOutputMatch {
+	regexMatch: RegExpMatchArray;
+	outputLines?: string[];
+}
+
+export interface IInternalOptions extends ITerminalQuickFixOptions {
+	type: 'internal';
+	getQuickFixes: TerminalQuickFixCallback;
+}
+
+export interface IResolvedExtensionOptions extends ITerminalQuickFixOptions {
+	type: 'resolved';
+	getQuickFixes: TerminalQuickFixCallbackExtension;
+}
+
+export interface IUnresolvedExtensionOptions extends ITerminalQuickFixOptions {
+	type: 'unresolved';
+}
+
+
+/**
+ * A matcher that runs on a sub-section of a terminal command's output
+ */
+export interface ITerminalOutputMatcher {
+	/**
+	 * A string or regex to match against the unwrapped line. If this is a regex with the multiline
+	 * flag, it will scan an amount of lines equal to `\n` instances in the regex + 1.
+	 */
+	lineMatcher: string | RegExp;
+	/**
+	 * Which side of the output to anchor the {@link offset} and {@link length} against.
+	 */
+	anchor: 'top' | 'bottom';
+	/**
+	 * The number of rows above or below the {@link anchor} to start matching against.
+	 */
+	offset: number;
+	/**
+	 * The number of rows to match against, this should be as small as possible for performance
+	 * reasons. This is capped at 40.
+	 */
+	length: number;
+
+	/**
+	 * If multiple matches are expected - this will result in {@link outputLines} being returned
+	 * when there's a {@link regexMatch} from {@link offset} to {@link length}
+	 */
+	multipleMatches?: boolean;
+}