Implement PR and issue chat context providers (#8169)

Part of microsoft/vscode#271104

Author: alexr00

package.json

@@ -12,6 +12,7 @@
 	},
 	"enabledApiProposals": [
 		"activeComment",
+		"chatContextProvider",
 		"chatParticipantAdditions",
 		"chatParticipantPrivate",
 		"chatSessionsProvider@3",
@@ -42,7 +43,7 @@
 	"version": "0.122.0",
 	"publisher": "GitHub",
 	"engines": {
-		"vscode": "^1.106.0"
+		"vscode": "^1.107.0"
 	},
 	"categories": [
 		"Other",
@@ -60,7 +61,9 @@
 		"onFileSystem:githubcommit",
 		"onFileSystem:review",
 		"onWebviewPanel:IssueOverview",
-		"onWebviewPanel:PullRequestOverview"
+		"onWebviewPanel:PullRequestOverview",
+		"onChatContextProvider:githubpr",
+		"onChatContextProvider:githubissue"
 	],
 	"browser": "./dist/browser/extension",
 	"l10n": "./dist/browser/extension",
@@ -72,6 +75,18 @@
 		"virtualWorkspaces": true
 	},
 	"contributes": {
+		"chatContext": [
+			{
+				"id": "githubpr",
+				"icon": "$(github)",
+				"displayName": "GitHub Pull Requests"
+			},
+			{
+				"id": "githubissue",
+				"icon": "$(issues)",
+				"displayName": "GitHub Issues"
+			}
+		],
 		"chatSessions": [
 			{
 				"type": "copilot-swe-agent",

src/@types/vscode.proposed.chatContextProvider.d.ts

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+declare module 'vscode' {
+
+	// https://github.com/microsoft/vscode/issues/271104 @alexr00
+
+	export namespace chat {
+
+		// TODO@alexr00 API:
+		// selector is confusing
+		export function registerChatContextProvider(selector: DocumentSelector, id: string, provider: ChatContextProvider): Disposable;
+
+	}
+
+	export interface ChatContextItem {
+		icon: ThemeIcon;
+		label: string;
+		modelDescription?: string;
+		value?: string;
+	}
+
+	export interface ChatContextProvider<T extends ChatContextItem = ChatContextItem> {
+
+		/**
+		 * Provide a list of chat context items that a user can choose from. These context items are shown as options when the user explicitly attaches context.
+		 * Chat context items can be provided without a `value`, as the `value` can be resolved later using `resolveChatContext`.
+		 * `resolveChatContext` is only called for items that do not have a `value`.
+		 *
+		 * @param options
+		 * @param token
+		 */
+		provideChatContextExplicit?(token: CancellationToken): ProviderResult<T[]>;
+
+		/**
+		 * Given a particular resource, provide a chat context item for it. This is used for implicit context (see the settings `chat.implicitContext.enabled` and `chat.implicitContext.suggestedContext`).
+		 * Chat context items can be provided without a `value`, as the `value` can be resolved later using `resolveChatContext`.
+		 * `resolveChatContext` is only called for items that do not have a `value`.
+		 *
+		 * @param resource
+		 * @param options
+		 * @param token
+		 */
+		provideChatContextForResource?(options: { resource: Uri }, token: CancellationToken): ProviderResult<T | undefined>;
+
+		/**
+		 * If a chat context item is provided without a `value`, from either of the `provide` methods, this method is called to resolve the `value` for the item.
+		 *
+		 * @param context
+		 * @param token
+		 */
+		resolveChatContext(context: T, token: CancellationToken): ProviderResult<ChatContextItem>;
+	}
+
+}

src/extension.ts

@@ -32,7 +32,10 @@ import { registerBuiltinGitProvider, registerLiveShareGitProvider } from './gitP
 import { GitHubContactServiceProvider } from './gitProviders/GitHubContactServiceProvider';
 import { GitLensIntegration } from './integrations/gitlens/gitlensImpl';
 import { IssueFeatureRegistrar } from './issues/issueFeatureRegistrar';
+import { StateManager } from './issues/stateManager';
+import { IssueContextProvider } from './lm/issueContextProvider';
 import { ChatParticipant, ChatParticipantState } from './lm/participants';
+import { PullRequestContextProvider } from './lm/pullRequestContextProvider';
 import { registerTools } from './lm/tools/tools';
 import { migrate } from './migrations';
 import { NotificationsFeatureRegister } from './notifications/notificationsFeatureRegistar';
@@ -253,10 +256,14 @@ async function init(
 	const layout = vscode.workspace.getConfiguration(PR_SETTINGS_NAMESPACE).get<string>(FILE_LIST_LAYOUT);
 	await vscode.commands.executeCommand('setContext', 'fileListLayout:flat', layout === 'flat');
 
-	const issuesFeatures = new IssueFeatureRegistrar(git, reposManager, reviewsManager, context, telemetry, copilotRemoteAgentManager);
+	const issueStateManager = new StateManager(git, reposManager, context);
+	const issuesFeatures = new IssueFeatureRegistrar(git, reposManager, reviewsManager, context, telemetry, issueStateManager, copilotRemoteAgentManager);
 	context.subscriptions.push(issuesFeatures);
 	await issuesFeatures.initialize();
 
+	vscode.chat.registerChatContextProvider({ scheme: 'webview-panel', pattern: '**/webview-PullRequestOverview**' }, 'githubpr', new PullRequestContextProvider(prsTreeModel, reposManager));
+	vscode.chat.registerChatContextProvider({ scheme: 'webview-panel', pattern: '**/webview-IssueOverview**' }, 'githubissue', new IssueContextProvider(issueStateManager, reposManager));
+
 	const notificationsFeatures = new NotificationsFeatureRegister(credentialStore, reposManager, telemetry, notificationsManager);
 	context.subscriptions.push(notificationsFeatures);
 

src/github/copilotPrWatcher.ts

@@ -268,7 +268,7 @@ export class CopilotPRWatcher extends Disposable {
 	private async _updateSingleState(pr: PullRequestModel): Promise<void> {
 		const changes: CodingAgentPRAndStatus[] = [];
 
-		const copilotEvents = await pr.getCopilotTimelineEvents(pr, false, !this._model.isInitialized);
+		const copilotEvents = await pr.getCopilotTimelineEvents(false, !this._model.isInitialized);
 		let latestEvent = copilotEventToStatus(copilotEvents[copilotEvents.length - 1]);
 		if (latestEvent === CopilotPRStatus.None) {
 			if (!COPILOT_ACCOUNTS[pr.author.login]) {

src/github/folderRepositoryManager.ts

@@ -2499,7 +2499,7 @@ export class FolderRepositoryManager extends Disposable {
 	private async promptPullBrach(pr: PullRequestModel, branch: Branch, autoStashSetting?: boolean) {
 		if (!this._updateMessageShown || autoStashSetting) {
 			// When the PR is from Copilot, we only want to show the notification when Copilot is done working
-			const copilotStatus = await pr.copilotWorkingStatus(pr);
+			const copilotStatus = await pr.copilotWorkingStatus();
 			if (copilotStatus === CopilotWorkingStatus.InProgress) {
 				return;
 			}

src/github/issueModel.ts

@@ -85,8 +85,8 @@ export class IssueModel<TItem extends Issue = Issue> extends Disposable {
 		}
 	}
 
-	get timelineEvents(): readonly TimelineEvent[] {
-		return this._timelineEvents ?? [];
+	get timelineEvents(): readonly TimelineEvent[] | undefined {
+		return this._timelineEvents;
 	}
 
 	protected set timelineEvents(timelineEvents: readonly TimelineEvent[]) {
@@ -469,8 +469,8 @@ export class IssueModel<TItem extends Issue = Issue> extends Disposable {
 		}
 	}
 
-	async getIssueTimelineEvents(issueModel: IssueModel): Promise<TimelineEvent[]> {
-		Logger.debug(`Fetch timeline events of issue #${issueModel.number} - enter`, GitHubRepository.ID);
+	async getIssueTimelineEvents(): Promise<TimelineEvent[]> {
+		Logger.debug(`Fetch timeline events of issue #${this.number} - enter`, GitHubRepository.ID);
 		const { query, remote, schema } = await this.githubRepository.ensure();
 
 		try {
@@ -479,7 +479,7 @@ export class IssueModel<TItem extends Issue = Issue> extends Disposable {
 				variables: {
 					owner: remote.owner,
 					name: remote.repositoryName,
-					number: issueModel.number,
+					number: this.number,
 				},
 			});
 
@@ -489,11 +489,11 @@ export class IssueModel<TItem extends Issue = Issue> extends Disposable {
 			}
 
 			const ret = data.repository.pullRequest.timelineItems.nodes;
-			const events = await parseCombinedTimelineEvents(ret, await this.getCopilotTimelineEvents(issueModel, true), this.githubRepository);
+			const events = await parseCombinedTimelineEvents(ret, await this.getCopilotTimelineEvents(true), this.githubRepository);
 
 			const crossRefs = events.filter((event): event is CrossReferencedEvent => {
 				if ((event.event === EventType.CrossReferenced) && !event.source.isIssue) {
-					return !this.githubRepository.getExistingPullRequestModel(event.source.number) && (compareIgnoreCase(event.source.owner, issueModel.remote.owner) === 0 && compareIgnoreCase(event.source.repo, issueModel.remote.repositoryName) === 0);
+					return !this.githubRepository.getExistingPullRequestModel(event.source.number) && (compareIgnoreCase(event.source.owner, this.remote.owner) === 0 && compareIgnoreCase(event.source.repo, this.remote.repositoryName) === 0);
 				}
 				return false;
 
@@ -504,7 +504,7 @@ export class IssueModel<TItem extends Issue = Issue> extends Disposable {
 				this.githubRepository.getPullRequest(unseenPrs.source.number);
 			}
 
-			issueModel.timelineEvents = events;
+			this.timelineEvents = events;
 			return events;
 		} catch (e) {
 			console.log(e);
@@ -515,55 +515,55 @@ export class IssueModel<TItem extends Issue = Issue> extends Disposable {
 	/**
 	 * TODO: @alexr00 we should delete this https://github.com/microsoft/vscode-pull-request-github/issues/6965
 	 */
-	async getCopilotTimelineEvents(issueModel: IssueModel, skipMerge: boolean = false, useCache: boolean = false): Promise<TimelineEvent[]> {
-		if (!COPILOT_ACCOUNTS[issueModel.author.login]) {
+	async getCopilotTimelineEvents(skipMerge: boolean = false, useCache: boolean = false): Promise<TimelineEvent[]> {
+		if (!COPILOT_ACCOUNTS[this.author.login]) {
 			return [];
 		}
 
-		Logger.debug(`Fetch Copilot timeline events of issue #${issueModel.number} - enter`, GitHubRepository.ID);
+		Logger.debug(`Fetch Copilot timeline events of issue #${this.number} - enter`, GitHubRepository.ID);
 
 		if (useCache && this._copilotTimelineEvents) {
-			Logger.debug(`Fetch Copilot timeline events of issue #${issueModel.number} (used cache) - exit`, GitHubRepository.ID);
+			Logger.debug(`Fetch Copilot timeline events of issue #${this.number} (used cache) - exit`, GitHubRepository.ID);
 
 			return this._copilotTimelineEvents;
 		}
 
 		const { octokit, remote } = await this.githubRepository.ensure();
 		try {
 			const timeline = await restPaginate<typeof octokit.api.issues.listEventsForTimeline, OctokitCommon.ListEventsForTimelineResponse>(octokit.api.issues.listEventsForTimeline, {
-				issue_number: issueModel.number,
+				issue_number: this.number,
 				owner: remote.owner,
 				repo: remote.repositoryName,
 				per_page: 100
 			});
 
-			const timelineEvents = parseSelectRestTimelineEvents(issueModel, timeline);
+			const timelineEvents = parseSelectRestTimelineEvents(this, timeline);
 			this._copilotTimelineEvents = timelineEvents;
 			if (timelineEvents.length === 0) {
 				return [];
 			}
 			if (!skipMerge) {
-				const oldLastEvent = issueModel.timelineEvents.length > 0 ? issueModel.timelineEvents[issueModel.timelineEvents.length - 1] : undefined;
+				const oldLastEvent = this.timelineEvents ? (this.timelineEvents.length > 0 ? this.timelineEvents[this.timelineEvents.length - 1] : undefined) : undefined;
 				let allEvents: TimelineEvent[];
 				if (!oldLastEvent) {
 					allEvents = timelineEvents;
 				} else {
 					const oldEventTime = (eventTime(oldLastEvent) ?? 0);
 					const newEvents = timelineEvents.filter(event => (eventTime(event) ?? 0) > oldEventTime);
-					allEvents = [...issueModel.timelineEvents, ...newEvents];
+					allEvents = [...(this.timelineEvents ?? []), ...newEvents];
 				}
-				issueModel.timelineEvents = allEvents;
+				this.timelineEvents = allEvents;
 			}
-			Logger.debug(`Fetch Copilot timeline events of issue #${issueModel.number} - exit`, GitHubRepository.ID);
+			Logger.debug(`Fetch Copilot timeline events of issue #${this.number} - exit`, GitHubRepository.ID);
 			return timelineEvents;
 		} catch (e) {
-			Logger.error(`Error fetching Copilot timeline events of issue #${issueModel.number} - ${formatError(e)}`, GitHubRepository.ID);
+			Logger.error(`Error fetching Copilot timeline events of issue #${this.number} - ${formatError(e)}`, GitHubRepository.ID);
 			return [];
 		}
 	}
 
-	async copilotWorkingStatus(issueModel: IssueModel): Promise<CopilotWorkingStatus | undefined> {
-		const copilotEvents = await this.getCopilotTimelineEvents(issueModel);
+	async copilotWorkingStatus(): Promise<CopilotWorkingStatus | undefined> {
+		const copilotEvents = await this.getCopilotTimelineEvents();
 		if (copilotEvents.length > 0) {
 			const lastEvent = copilotEvents[copilotEvents.length - 1];
 			if (lastEvent.event === EventType.CopilotFinished) {

src/github/issueOverview.ts

@@ -255,7 +255,7 @@ export class IssueOverviewPanel<TItem extends IssueModel = IssueModel> extends W
 					issueModel.remote.repositoryName,
 					issueModel.number,
 				),
-				issueModel.getIssueTimelineEvents(issueModel),
+				issueModel.getIssueTimelineEvents(),
 				this._folderRepositoryManager.getPullRequestRepositoryAccessAndMergeMethods(issueModel),
 				issueModel.canEdit(),
 				this._folderRepositoryManager.getAssignableUsers(),
@@ -509,7 +509,7 @@ export class IssueOverviewPanel<TItem extends IssueModel = IssueModel> extends W
 	}
 
 	protected _getTimeline(): Promise<TimelineEvent[]> {
-		return this._item.getIssueTimelineEvents(this._item);
+		return this._item.getIssueTimelineEvents();
 	}
 
 	private async changeAssignees(message: IRequestMessage<void>): Promise<void> {