Use command for opening issues on remote providers.

It lets us track the source of event.
(#4764, #4765, PLG-139)

Author: sergeibbb

contributions.json

@@ -4090,6 +4090,10 @@
 				]
 			}
 		},
+		"gitlens.openIssueOnRemote": {
+			"label": "Open Issue on Remote",
+			"icon": "$(globe)"
+		},
 		"gitlens.openOnlyChangedFiles": {
 			"label": "Open Changed & Close Unchanged Files",
 			"commandPalette": "gitlens:enabled",

package.json

@@ -7822,6 +7822,11 @@
 				"title": "Open Folder History in Commit Graph",
 				"icon": "$(gitlens-graph)"
 			},
+			{
+				"command": "gitlens.openIssueOnRemote",
+				"title": "Open Issue on Remote",
+				"icon": "$(globe)"
+			},
 			{
 				"command": "gitlens.openOnlyChangedFiles",
 				"title": "Open Changed & Close Unchanged Files",
@@ -12800,6 +12805,10 @@
 					"command": "gitlens.openFolderHistoryInGraph:scm",
 					"when": "false"
 				},
+				{
+					"command": "gitlens.openIssueOnRemote",
+					"when": "false"
+				},
 				{
 					"command": "gitlens.openOnlyChangedFiles",
 					"when": "gitlens:enabled"

src/api/actionRunners.ts

@@ -12,7 +12,7 @@ import { sortCompare } from '../system/string';
 import type { Action, ActionContext, ActionRunner } from './gitlens';
 
 type Actions = ActionContext['type'];
-const actions: Actions[] = ['createPullRequest', 'openPullRequest', 'hover.commands'];
+const actions: Actions[] = ['createPullRequest', 'openPullRequest', 'openIssue', 'hover.commands'];
 
 // The order here determines the sorting of these actions when shown to the user
 export const enum ActionRunnerType {
@@ -288,6 +288,10 @@ export class ActionRunners implements Disposable {
 								title = 'Open Pull Request';
 								placeholder = 'Choose how to open the pull request';
 								break;
+							case 'openIssue':
+								title = 'Open Issue';
+								placeholder = 'Choose how to open the issue';
+								break;
 							case 'hover.commands':
 								title = 'Need Help or Want to Collaborate?';
 								placeholder = 'Choose what you would like to do';

src/api/gitlens.d.ts

@@ -41,6 +41,15 @@ export interface OpenPullRequestActionContext {
 	readonly source?: Source;
 }
 
+export interface OpenIssueActionContext {
+	readonly type: 'openIssue';
+	readonly provider: RemoteProvider | undefined;
+	readonly issue: {
+		readonly url: string;
+	};
+	readonly source?: Source;
+}
+
 export interface HoverCommandsActionContext {
 	readonly type: 'hover.commands';
 
@@ -62,7 +71,11 @@ export interface HoverCommandsActionContext {
 	readonly source?: Source;
 }
 
-export type ActionContext = CreatePullRequestActionContext | OpenPullRequestActionContext | HoverCommandsActionContext;
+export type ActionContext =
+	| CreatePullRequestActionContext
+	| OpenPullRequestActionContext
+	| OpenIssueActionContext
+	| HoverCommandsActionContext;
 export type Action<T extends ActionContext> = T['type'];
 
 export interface ActionRunner<T extends ActionContext = ActionContext> {

src/autolinks/autolinksProvider.ts

@@ -1,7 +1,10 @@
 import type { ConfigurationChangeEvent } from 'vscode';
 import { Disposable } from 'vscode';
+import type { OpenIssueActionContext } from '../api/gitlens';
+import { OpenIssueOnRemoteCommand } from '../commands/openIssueOnRemote';
 import { GlyphChars } from '../constants';
 import type { IntegrationIds } from '../constants.integrations';
+import type { Source } from '../constants.telemetry';
 import type { Container } from '../container';
 import type { GitRemote } from '../git/models/remote';
 import type { RemoteProvider, RemoteProviderId } from '../git/remotes/remoteProvider';
@@ -279,6 +282,7 @@ export class AutolinksProvider implements Disposable {
 		enrichedAutolinks?: Map<string, MaybeEnrichedAutolink>,
 		prs?: Set<string>,
 		footnotes?: Map<number, string>,
+		source?: Source,
 	): string {
 		const includeFootnotesInText = outputFormat === 'plaintext' && footnotes == null;
 		if (includeFootnotesInText) {
@@ -291,15 +295,31 @@ export class AutolinksProvider implements Disposable {
 			for (const [, [, link]] of enrichedAutolinks) {
 				if (this.ensureAutolinkCached(link)) {
 					if (link.tokenize != null) {
-						text = link.tokenize(text, outputFormat, tokenMapping, enrichedAutolinks, prs, footnotes);
+						text = link.tokenize(
+							text,
+							outputFormat,
+							tokenMapping,
+							enrichedAutolinks,
+							prs,
+							footnotes,
+							source,
+						);
 					}
 				}
 			}
 		} else {
 			for (const ref of this._references) {
 				if (this.ensureAutolinkCached(ref)) {
 					if (ref.tokenize != null) {
-						text = ref.tokenize(text, outputFormat, tokenMapping, enrichedAutolinks, prs, footnotes);
+						text = ref.tokenize(
+							text,
+							outputFormat,
+							tokenMapping,
+							enrichedAutolinks,
+							prs,
+							footnotes,
+							source,
+						);
 					}
 				}
 			}
@@ -323,6 +343,7 @@ export class AutolinksProvider implements Disposable {
 									enrichedAutolinks,
 									prs,
 									footnotes,
+									source,
 								);
 							}
 						}
@@ -361,6 +382,7 @@ export class AutolinksProvider implements Disposable {
 				enrichedAutolinks?: Map<string, MaybeEnrichedAutolink>,
 				prs?: Set<string>,
 				footnotes?: Map<number, string>,
+				source?: Source,
 			) => {
 				let footnoteIndex: number;
 
@@ -370,7 +392,15 @@ export class AutolinksProvider implements Disposable {
 						return text.replace(
 							ref.messageMarkdownRegex,
 							(_: string, prefix: string, linkText: string, num: string) => {
-								const url = encodeUrl(ref.url.replace(numRegex, num));
+								const rawUrl = encodeUrl(ref.url.replace(numRegex, num));
+								const footnoteSource = source && { ...source, detail: 'footnote' };
+								const urlCommandContext: {
+									provider: undefined | OpenIssueActionContext['provider'];
+									issue: { url: string };
+								} = {
+									provider: undefined,
+									issue: { url: rawUrl },
+								};
 
 								let title = '';
 								if (ref.title) {
@@ -380,6 +410,10 @@ export class AutolinksProvider implements Disposable {
 									if (issueResult?.value != null) {
 										if (issueResult.paused) {
 											if (footnotes != null && !prs?.has(num)) {
+												const url = OpenIssueOnRemoteCommand.createMarkdownCommandLink({
+													...urlCommandContext,
+													source: footnoteSource,
+												});
 												const name =
 													ref.description?.replace(numRegex, num) ??
 													`Custom Autolink ${ref.prefix}${num}`;
@@ -396,6 +430,16 @@ export class AutolinksProvider implements Disposable {
 											const issueTitle = escapeMarkdown(issue.title.trim());
 											const issueTitleQuoteEscaped = issueTitle.replace(/"/g, '\\"');
 
+											urlCommandContext.provider = issue.provider && {
+												id: issue.provider.id,
+												name: issue.provider.name,
+												domain: issue.provider.domain,
+											};
+											const url = OpenIssueOnRemoteCommand.createMarkdownCommandLink({
+												...urlCommandContext,
+												source: footnoteSource,
+											});
+
 											if (footnotes != null && !prs?.has(num)) {
 												footnoteIndex = footnotes.size + 1;
 												footnotes.set(
@@ -417,6 +461,10 @@ export class AutolinksProvider implements Disposable {
 											)}`;
 										}
 									} else if (footnotes != null && !prs?.has(num)) {
+										const url = OpenIssueOnRemoteCommand.createMarkdownCommandLink({
+											...urlCommandContext,
+											source: footnoteSource,
+										});
 										const name =
 											ref.description?.replace(numRegex, num) ??
 											`Custom Autolink ${ref.prefix}${num}`;
@@ -429,6 +477,10 @@ export class AutolinksProvider implements Disposable {
 									title += '"';
 								}
 
+								const url = OpenIssueOnRemoteCommand.createMarkdownCommandLink({
+									...urlCommandContext,
+									source: source,
+								});
 								const token = `\x00${tokenMapping.size}\x00`;
 								tokenMapping.set(token, `[${linkText}](${url}${title})`);
 								return `${prefix}${token}`;

src/autolinks/models/autolinks.ts

@@ -1,3 +1,4 @@
+import type { Source } from '../../constants.telemetry';
 import type { IssueOrPullRequest } from '../../git/models/issueOrPullRequest';
 import type { ProviderReference } from '../../git/models/remoteProvider';
 import type { ResourceDescriptor } from '../../git/models/resourceDescriptor';
@@ -49,6 +50,7 @@ export interface CacheableAutolinkReference extends AutolinkReference {
 				enrichedAutolinks?: Map<string, MaybeEnrichedAutolink>,
 				prs?: Set<string>,
 				footnotes?: Map<number, string>,
+				source?: Source,
 		  ) => string)
 		| null;
 
@@ -67,6 +69,7 @@ export interface DynamicAutolinkReference {
 				enrichedAutolinks?: Map<string, MaybeEnrichedAutolink>,
 				prs?: Set<string>,
 				footnotes?: Map<number, string>,
+				source?: Source,
 		  ) => string)
 		| null;
 	parse: (text: string, autolinks: Map<string, Autolink>) => void;

src/commands.ts

@@ -47,6 +47,7 @@ import './commands/openFileOnRemote';
 import './commands/openFileAtRevision';
 import './commands/openFileAtRevisionFrom';
 import './commands/openOnRemote';
+import './commands/openIssueOnRemote';
 import './commands/openPullRequestOnRemote';
 import './commands/openRepoOnRemote';
 import './commands/openRevisionFile';

src/commands/openIssueOnRemote.ts

@@ -0,0 +1,42 @@
+import { env, window } from 'vscode';
+import type { OpenIssueActionContext } from '../api/gitlens';
+import { actionCommandPrefix } from '../constants.commands';
+import { command } from '../system/-webview/command';
+import { openUrl } from '../system/-webview/vscode/uris';
+import { createMarkdownCommandLink } from '../system/commands';
+import { Logger } from '../system/logger';
+import { getLogScope } from '../system/logger.scope';
+import { GlCommandBase } from './commandBase';
+
+export interface OpenIssueOnRemoteCommandArgs {
+	clipboard?: boolean;
+	issue?: { url: string };
+}
+
+@command()
+export class OpenIssueOnRemoteCommand extends GlCommandBase {
+	static createMarkdownCommandLink(args: Omit<OpenIssueActionContext, 'type'>): string {
+		return createMarkdownCommandLink(`${actionCommandPrefix}openIssue`, {
+			...args,
+			type: 'openIssue',
+		});
+	}
+
+	constructor() {
+		super('gitlens.openIssueOnRemote');
+	}
+
+	async execute(args?: OpenIssueOnRemoteCommandArgs): Promise<void> {
+		if (args?.issue == null) {
+			void window.showInformationMessage('No issue provided');
+			Logger.warn(getLogScope(), 'No issue provided in OpenIssueOnRemoteCommand', args);
+			return;
+		}
+
+		if (args.clipboard) {
+			await env.clipboard.writeText(args.issue.url);
+		} else {
+			void openUrl(args.issue.url);
+		}
+	}
+}

src/constants.commands.generated.ts

@@ -1077,4 +1077,5 @@ export type ContributedKeybindingCommands =
 export type ContributedOrphansOrInternalCommands =
 	| 'gitlens.graph.pushWithForce'
 	| 'gitlens.openFolderHistoryInGraph'
+	| 'gitlens.openIssueOnRemote'
 	| 'gitlens.plus.cloudIntegrations.connect';

src/extension.ts

@@ -4,8 +4,14 @@ import { hrtime } from '@env/hrtime';
 import { loggingJsonReplacer } from '@env/json';
 import { isWeb } from '@env/platform';
 import { Api } from './api/api';
-import type { CreatePullRequestActionContext, GitLensApi, OpenPullRequestActionContext } from './api/gitlens';
+import type {
+	CreatePullRequestActionContext,
+	GitLensApi,
+	OpenIssueActionContext,
+	OpenPullRequestActionContext,
+} from './api/gitlens';
 import type { CreatePullRequestOnRemoteCommandArgs } from './commands/createPullRequestOnRemote';
+import type { OpenIssueOnRemoteCommandArgs } from './commands/openIssueOnRemote';
 import type { OpenPullRequestOnRemoteCommandArgs } from './commands/openPullRequestOnRemote';
 import { fromOutputLevel } from './config';
 import { trackableSchemes } from './constants';
@@ -338,6 +344,16 @@ function registerBuiltInActionRunners(container: Container): void {
 				}));
 			},
 		}),
+		container.actionRunners.registerBuiltIn<OpenIssueActionContext>('openIssue', {
+			label: ctx => `Open Issue on ${ctx.provider?.name ?? 'Remote'}`,
+			run: async ctx => {
+				if (ctx.type !== 'openIssue') return;
+
+				void (await executeCommand<OpenIssueOnRemoteCommandArgs>('gitlens.openIssueOnRemote', {
+					issue: { url: ctx.issue.url },
+				}));
+			},
+		}),
 	);
 }