Add UpdateQueryTool for automatic query updates from chat

Author: Copilot

src/common/settingsUtils.ts

@@ -91,7 +91,7 @@ export function editQuery(namespace: string, queryName: string) {
 			inputBox.dispose();
 		} else if (inputBox.selectedItems[0] === inputBox.items[3]) {
 			inputBox.ignoreFocusOut = true;
-			await openCopilotForQuery(inputBox.value);
+			await openCopilotForQuery(inputBox.value, namespace, queryName);
 			inputBox.busy = false;
 		}
 	});
@@ -165,8 +165,8 @@ async function openSettingsAtQuery(config: vscode.WorkspaceConfiguration, inspec
 	}
 }
 
-async function openCopilotForQuery(currentQuery: string) {
-	const chatMessage = vscode.l10n.t('I want to edit this GitHub search query: \n```\n{0}\n```\nOutput only one, minimally modified query in a codeblock.\nModify it so that it ', currentQuery);
+async function openCopilotForQuery(currentQuery: string, namespace: string, queryName: string) {
+	const chatMessage = vscode.l10n.t('I want to edit this GitHub search query for "{0}": \n```\n{1}\n```\n\nPlease modify the query as needed and then use the update_query tool to save the changes automatically. The namespace is "{2}" and the query name is "{3}".', queryName, currentQuery, namespace, queryName);
 
 	// Open chat with the query pre-populated
 	await vscode.commands.executeCommand(commands.OPEN_CHAT, { query: chatMessage, isPartialQuery: true });

src/lm/tools/tools.ts

@@ -20,13 +20,15 @@ import { ConvertToSearchSyntaxTool, SearchTool } from './searchTools';
 import { SuggestFixTool } from './suggestFixTool';
 import { IssueSummarizationTool } from './summarizeIssueTool';
 import { NotificationSummarizationTool } from './summarizeNotificationsTool';
+import { UpdateQueryTool } from './updateQueryTool';
 
 export function registerTools(context: vscode.ExtensionContext, credentialStore: CredentialStore, repositoriesManager: RepositoriesManager, chatParticipantState: ChatParticipantState, copilotRemoteAgentManager: CopilotRemoteAgentManager, telemetry: ITelemetry) {
 	registerFetchingTools(context, credentialStore, repositoriesManager, chatParticipantState);
 	registerSummarizationTools(context);
 	registerSuggestFixTool(context, credentialStore, repositoriesManager, chatParticipantState);
 	registerSearchTools(context, credentialStore, repositoriesManager, chatParticipantState);
 	registerCopilotAgentTools(context, copilotRemoteAgentManager, telemetry);
+	registerUpdateQueryTool(context);
 	context.subscriptions.push(vscode.lm.registerTool(ActivePullRequestTool.toolId, new ActivePullRequestTool(repositoriesManager, copilotRemoteAgentManager)));
 	context.subscriptions.push(vscode.lm.registerTool(OpenPullRequestTool.toolId, new OpenPullRequestTool(repositoriesManager, copilotRemoteAgentManager)));
 }
@@ -53,4 +55,8 @@ function registerSearchTools(context: vscode.ExtensionContext, credentialStore:
 	context.subscriptions.push(vscode.lm.registerTool(ConvertToSearchSyntaxTool.toolId, new ConvertToSearchSyntaxTool(credentialStore, repositoriesManager, chatParticipantState)));
 	context.subscriptions.push(vscode.lm.registerTool(SearchTool.toolId, new SearchTool(credentialStore, repositoriesManager, chatParticipantState)));
 	context.subscriptions.push(vscode.lm.registerTool(DisplayIssuesTool.toolId, new DisplayIssuesTool(context, chatParticipantState)));
+}
+
+function registerUpdateQueryTool(context: vscode.ExtensionContext) {
+	context.subscriptions.push(vscode.lm.registerTool(UpdateQueryTool.toolId, new UpdateQueryTool()));
 }

src/lm/tools/updateQueryTool.ts

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as vscode from 'vscode';
+import { ISSUES_SETTINGS_NAMESPACE, PR_SETTINGS_NAMESPACE, QUERIES } from '../../common/settingKeys';
+
+interface UpdateQueryParameters {
+	namespace: string;
+	queryName: string;
+	newQuery: string;
+}
+
+export class UpdateQueryTool implements vscode.LanguageModelTool<UpdateQueryParameters> {
+	public static readonly toolId = 'github-pull-request_update_query';
+
+	async prepareInvocation(options: vscode.LanguageModelToolInvocationPrepareOptions<UpdateQueryParameters>): Promise<vscode.PreparedToolInvocation> {
+		return {
+			invocationMessage: vscode.l10n.t('Updating query "{0}"', options.input.queryName || 'unnamed')
+		};
+	}
+
+	async invoke(options: vscode.LanguageModelToolInvocationOptions<UpdateQueryParameters>, _token: vscode.CancellationToken): Promise<vscode.LanguageModelToolResult | undefined> {
+		const { namespace, queryName, newQuery } = options.input;
+
+		// Validate inputs
+		if (!namespace || !queryName || !newQuery) {
+			const errorMessage = vscode.l10n.t('Missing required parameters: namespace, queryName, and newQuery are all required');
+			return new vscode.LanguageModelToolResult([new vscode.LanguageModelTextPart(errorMessage)]);
+		}
+
+		// Validate namespace
+		if (namespace !== PR_SETTINGS_NAMESPACE && namespace !== ISSUES_SETTINGS_NAMESPACE) {
+			const errorMessage = vscode.l10n.t('Invalid namespace: must be either "{0}" or "{1}"', PR_SETTINGS_NAMESPACE, ISSUES_SETTINGS_NAMESPACE);
+			return new vscode.LanguageModelToolResult([new vscode.LanguageModelTextPart(errorMessage)]);
+		}
+
+		try {
+			const config = vscode.workspace.getConfiguration(namespace);
+			const inspect = config.inspect<{ label: string; query: string }[]>(QUERIES);
+
+			// Find the target to update based on the hierarchy
+			let newValue: { label: string; query: string }[];
+			let target: vscode.ConfigurationTarget;
+
+			if (inspect?.workspaceFolderValue) {
+				target = vscode.ConfigurationTarget.WorkspaceFolder;
+				newValue = [...inspect.workspaceFolderValue];
+			} else if (inspect?.workspaceValue) {
+				target = vscode.ConfigurationTarget.Workspace;
+				newValue = [...inspect.workspaceValue];
+			} else {
+				target = vscode.ConfigurationTarget.Global;
+				newValue = [...(config.get<{ label: string; query: string }[]>(QUERIES) ?? [])];
+			}
+
+			// Find and update the query
+			const queryIndex = newValue.findIndex(query => query.label === queryName);
+			if (queryIndex === -1) {
+				const errorMessage = vscode.l10n.t('Query "{0}" not found', queryName);
+				return new vscode.LanguageModelToolResult([new vscode.LanguageModelTextPart(errorMessage)]);
+			}
+
+			const oldQuery = newValue[queryIndex].query;
+			newValue[queryIndex].query = newQuery;
+
+			// Update the configuration
+			await config.update(QUERIES, newValue, target);
+
+			const successMessage = vscode.l10n.t('Successfully updated query "{0}" from "{1}" to "{2}"', queryName, oldQuery, newQuery);
+			return new vscode.LanguageModelToolResult([new vscode.LanguageModelTextPart(successMessage)]);
+
+		} catch (error) {
+			const errorMessage = vscode.l10n.t('Failed to update query: {0}', error instanceof Error ? error.message : String(error));
+			return new vscode.LanguageModelToolResult([new vscode.LanguageModelTextPart(errorMessage)]);
+		}
+	}
+}

src/lm/tools/updateQueryTool.ts.bak

@@ -0,0 +1,94 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as vscode from 'vscode';
+import { FetchIssueResult } from './fetchIssueTool';
+import { concatAsyncIterable } from './toolsUtils';
+
+export class IssueSummarizationTool implements vscode.LanguageModelTool<FetchIssueResult> {
+	public static readonly toolId = 'github-pull-request_issue_summarize';
+
+	async prepareInvocation(options: vscode.LanguageModelToolInvocationPrepareOptions<FetchIssueResult>): Promise<vscode.PreparedToolInvocation> {
+		if (!options.input.title) {
+			return {
+				invocationMessage: vscode.l10n.t('Summarizing issue')
+			};
+		}
+		const shortenedTitle = options.input.title.length > 40;
+		const maxLengthTitle = shortenedTitle ? options.input.title.substring(0, 40) : options.input.title;
+		return {
+			invocationMessage: vscode.l10n.t('Summarizing "{0}', maxLengthTitle)
+		};
+	}
+
+	async invoke(options: vscode.LanguageModelToolInvocationOptions<FetchIssueResult>, _token: vscode.CancellationToken): Promise<vscode.LanguageModelToolResult | undefined> {
+		let issueOrPullRequestInfo: string = `
+Title : ${options.input.title}
+Body : ${options.input.body}
+`;
+		const fileChanges = options.input.fileChanges;
+		if (fileChanges) {
+			issueOrPullRequestInfo += `
+The following are the files changed:
+`;
+			for (const fileChange of fileChanges.values()) {
+				issueOrPullRequestInfo += `
+File : ${fileChange.fileName}
+Patch: ${fileChange.patch}
+`;
+			}
+		}
+		const comments = options.input.comments;
+		if (comments) {
+			for (const [index, comment] of comments.entries()) {
+				issueOrPullRequestInfo += `
+Comment ${index} :
+Author: ${comment.author}
+Body: ${comment.body}
+`;
+			}
+		}
+		const models = await vscode.lm.selectChatModels({
+			vendor: 'copilot',
+			family: 'gpt-4o'
+		});
+		const model = models[0];
+		const repo = options.input.repo;
+		const owner = options.input.owner;
+
+		if (model && repo && owner) {
+			const messages = [vscode.LanguageModelChatMessage.User(this.summarizeInstructions(repo, owner))];
+			messages.push(vscode.LanguageModelChatMessage.User(`The issue or pull request information is as follows:`));
+			messages.push(vscode.LanguageModelChatMessage.User(issueOrPullRequestInfo));
+			const response = await model.sendRequest(messages, {});
+			const responseText = await concatAsyncIterable(response.text);
+			return new vscode.LanguageModelToolResult([new vscode.LanguageModelTextPart(responseText)]);
+		} else {
+			return new vscode.LanguageModelToolResult([new vscode.LanguageModelTextPart(issueOrPullRequestInfo)]);
+		}
+	}
+
+	private summarizeInstructions(repo: string, owner: string): string {
+		return `
+You are an AI assistant who is very proficient in summarizing issues and pull requests (PRs).
+You will be given information relative to an issue or PR : the title, the body and the comments. In the case of a PR you will also be given patches of the PR changes.
+Your task is to output a summary of all this information.
+Do not output code. When you try to summarize PR changes, summarize in a textual format.
+Output references to other issues and PRs as Markdown links. The current issue has owner ${owner} and is in the repo ${repo}.
+If a comment references for example issue or PR #123, then output either of the following in the summary depending on if it is an issue or a PR:
+
+[#123](https://github.com/${owner}/${repo}/issues/123)
+[#123](https://github.com/${owner}/${repo}/pull/123)
+
+When you summarize comments, always give a summary of each comment and always mention the author clearly before the comment. If the author is called 'joe' and the comment is 'this is a comment', then the output should be:
+
+joe: this is a comment
+
+Make sure the summary is at least as short or shorter than the issue or PR with the comments and the patches if there are.
+`;
+	}
+
+}

src/test/lm/tools/updateQueryTool.test.ts

@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { default as assert } from 'assert';
+import { SinonSandbox, createSandbox } from 'sinon';
+import * as vscode from 'vscode';
+import { UpdateQueryTool } from '../../../lm/tools/updateQueryTool';
+import { ISSUES_SETTINGS_NAMESPACE, PR_SETTINGS_NAMESPACE } from '../../../common/settingKeys';
+
+describe('UpdateQueryTool', function () {
+	let sinon: SinonSandbox;
+	let tool: UpdateQueryTool;
+
+	beforeEach(function () {
+		sinon = createSandbox();
+		tool = new UpdateQueryTool();
+	});
+
+	afterEach(function () {
+		sinon.restore();
+	});
+
+	describe('toolId', function () {
+		it('should have the correct tool ID', function () {
+			assert.strictEqual(UpdateQueryTool.toolId, 'github-pull-request_update_query');
+		});
+	});
+
+	describe('prepareInvocation()', function () {
+		it('should return the correct invocation message', async function () {
+			const mockInput = {
+				namespace: PR_SETTINGS_NAMESPACE,
+				queryName: 'My Queries',
+				newQuery: 'is:pr state:open'
+			};
+
+			const result = await tool.prepareInvocation({ input: mockInput } as any);
+			assert.strictEqual(result.invocationMessage, 'Updating query "My Queries"');
+		});
+
+		it('should handle unnamed query', async function () {
+			const mockInput = {
+				namespace: PR_SETTINGS_NAMESPACE,
+				queryName: '',
+				newQuery: 'is:pr state:open'
+			};
+
+			const result = await tool.prepareInvocation({ input: mockInput } as any);
+			assert.strictEqual(result.invocationMessage, 'Updating query "unnamed"');
+		});
+	});
+
+	describe('invoke()', function () {
+		it('should return error for missing parameters', async function () {
+			const mockInput = {
+				namespace: '',
+				queryName: '',
+				newQuery: ''
+			};
+
+			const result = await tool.invoke({ input: mockInput } as any, {} as any);
+			assert.ok(result);
+			const textPart = result.content[0] as vscode.LanguageModelTextPart;
+			assert.ok(textPart.value.includes('Missing required parameters'));
+		});
+
+		it('should return error for invalid namespace', async function () {
+			const mockInput = {
+				namespace: 'invalid',
+				queryName: 'test',
+				newQuery: 'is:pr state:open'
+			};
+
+			const result = await tool.invoke({ input: mockInput } as any, {} as any);
+			assert.ok(result);
+			const textPart = result.content[0] as vscode.LanguageModelTextPart;
+			assert.ok(textPart.value.includes('Invalid namespace'));
+		});
+
+		it('should accept valid namespaces', async function () {
+			// Mock workspace configuration
+			const mockConfig = {
+				inspect: sinon.stub().returns({ workspaceValue: [{ label: 'test', query: 'old query' }] }),
+				get: sinon.stub().returns([{ label: 'test', query: 'old query' }]),
+				update: sinon.stub().resolves()
+			};
+			sinon.stub(vscode.workspace, 'getConfiguration').returns(mockConfig as any);
+
+			const prInput = {
+				namespace: PR_SETTINGS_NAMESPACE,
+				queryName: 'test',
+				newQuery: 'is:pr state:open'
+			};
+
+			const result1 = await tool.invoke({ input: prInput } as any, {} as any);
+			assert.ok(result1);
+			const textPart1 = result1.content[0] as vscode.LanguageModelTextPart;
+			assert.ok(textPart1.value.includes('Successfully updated query'));
+
+			const issuesInput = {
+				namespace: ISSUES_SETTINGS_NAMESPACE,
+				queryName: 'test',
+				newQuery: 'is:issue state:open'
+			};
+
+			const result2 = await tool.invoke({ input: issuesInput } as any, {} as any);
+			assert.ok(result2);
+			const textPart2 = result2.content[0] as vscode.LanguageModelTextPart;
+			assert.ok(textPart2.value.includes('Successfully updated query'));
+		});
+	});
+});