@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/tools/renameTool.js

@@ -0,0 +1,242 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { ResourceTextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService';
+import { IBulkEditService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService.service';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { rename } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/rename/browser/rename';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { createToolSimpleTextResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolHelpers';
+import { resolveToolUri, errorResult, findLineNumber, findSymbolColumn } from './toolHelpers.js';
+
+const RenameToolId = "vscode_renameSymbol";
+const BaseModelDescription = `Rename a code symbol across the workspace using the language server's rename functionality. This performs a precise, semantics-aware rename that updates all references.
+
+Input:
+- "symbol": The exact current name of the symbol to rename.
+- "newName": The new name for the symbol.
+- "uri": A full URI (e.g. "file:///path/to/file.ts") of a file where the symbol appears. Provide either "uri" or "filePath".
+- "filePath": A workspace-relative file path (e.g. "src/utils/helpers.ts") of a file where the symbol appears. Provide either "uri" or "filePath".
+- "lineContent": A substring of the line of code where the symbol appears. This is used to locate the exact position in the file. Must be the actual text from the file - do NOT fabricate it.
+
+IMPORTANT: The file and line do NOT need to be the definition of the symbol. Any occurrence works - a usage, an import, a call site, etc. You can pick whichever occurrence is most convenient.
+
+If the tool returns an error, retry with corrected input - ensure the file path is correct, the line content matches the actual file content, and the symbol name appears in that line.`;
+let RenameTool = class RenameTool extends Disposable {
+    constructor(
+        _languageFeaturesService,
+        _textModelService,
+        _workspaceContextService,
+        _chatService,
+        _bulkEditService
+    ) {
+        super();
+        this._languageFeaturesService = _languageFeaturesService;
+        this._textModelService = _textModelService;
+        this._workspaceContextService = _workspaceContextService;
+        this._chatService = _chatService;
+        this._bulkEditService = _bulkEditService;
+        this._onDidUpdateToolData = this._store.add(( new Emitter()));
+        this.onDidUpdateToolData = this._onDidUpdateToolData.event;
+        this._store.add(
+            Event.debounce(this._languageFeaturesService.renameProvider.onDidChange, () => {}, 2000)((() => this._onDidUpdateToolData.fire()))
+        );
+    }
+    getToolData() {
+        const languageIds = this._languageFeaturesService.renameProvider.registeredLanguageIds;
+        let modelDescription = BaseModelDescription;
+        if (( languageIds.has("*"))) {
+            modelDescription += "\n\nSupported for all languages.";
+        } else if (languageIds.size > 0) {
+            const sorted = [...languageIds].sort();
+            modelDescription += `\n\nCurrently supported for: ${sorted.join(", ")}.`;
+        } else {
+            modelDescription += "\n\nNo languages currently have rename providers registered.";
+        }
+        return {
+            id: RenameToolId,
+            toolReferenceName: "rename",
+            canBeReferencedInPrompt: false,
+            icon: ThemeIcon.fromId(Codicon.rename.id),
+            displayName: ( localize(6460, "Rename Symbol")),
+            userDescription: ( localize(6461, "Rename a symbol across the workspace")),
+            modelDescription,
+            source: ToolDataSource.Internal,
+            when: ( ContextKeyExpr.has("config.chat.tools.renameTool.enabled")),
+            inputSchema: {
+                type: "object",
+                properties: {
+                    symbol: {
+                        type: "string",
+                        description: "The exact current name of the symbol to rename."
+                    },
+                    newName: {
+                        type: "string",
+                        description: "The new name for the symbol."
+                    },
+                    uri: {
+                        type: "string",
+                        description: "A full URI of a file where the symbol appears (e.g. \"file:///path/to/file.ts\"). Provide either \"uri\" or \"filePath\"."
+                    },
+                    filePath: {
+                        type: "string",
+                        description: "A workspace-relative file path where the symbol appears (e.g. \"src/utils/helpers.ts\"). Provide either \"uri\" or \"filePath\"."
+                    },
+                    lineContent: {
+                        type: "string",
+                        description: "A substring of the line of code where the symbol appears. Used to locate the exact position. Must be actual text from the file."
+                    }
+                },
+                required: ["symbol", "newName", "lineContent"]
+            }
+        };
+    }
+    async prepareToolInvocation(context, _token) {
+        const input = context.parameters;
+        return {
+            invocationMessage: ( localize(6462, "Renaming `{0}` to `{1}`", input.symbol, input.newName))
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const input = invocation.parameters;
+        const uri = resolveToolUri(input, this._workspaceContextService);
+        if (!uri) {
+            return errorResult(
+                "Provide either \"uri\" (a full URI) or \"filePath\" (a workspace-relative path) to identify the file."
+            );
+        }
+        const ref = await this._textModelService.createModelReference(uri);
+        try {
+            const model = ref.object.textEditorModel;
+            if (!( this._languageFeaturesService.renameProvider.has(model))) {
+                return errorResult(
+                    `No rename provider available for this file's language. The rename tool may not support this language.`
+                );
+            }
+            const lineNumber = findLineNumber(model, input.lineContent);
+            if (lineNumber === undefined) {
+                return errorResult(`Could not find line content "${input.lineContent}" in ${( uri.toString())}. Provide the exact text from the line where the symbol appears.`);
+            }
+            const lineText = model.getLineContent(lineNumber);
+            const column = findSymbolColumn(lineText, input.symbol);
+            if (column === undefined) {
+                return errorResult(
+                    `Could not find symbol "${input.symbol}" in the matched line. Ensure the symbol name is correct and appears in the provided line content.`
+                );
+            }
+            const position = ( new Position(lineNumber, column));
+            const renameResult = await rename(
+                this._languageFeaturesService.renameProvider,
+                model,
+                position,
+                input.newName
+            );
+            if (renameResult.rejectReason) {
+                return errorResult(`Rename rejected: ${renameResult.rejectReason}`);
+            }
+            if (renameResult.edits.length === 0) {
+                return errorResult(`Rename produced no edits.`);
+            }
+            if (invocation.context) {
+                const chatModel = this._chatService.getSession(invocation.context.sessionResource);
+                const request = chatModel?.getRequests().at(-1);
+                if (chatModel && request) {
+                    const editsByUri = ( new ResourceMap());
+                    for (const edit of renameResult.edits) {
+                        if (ResourceTextEdit.is(edit)) {
+                            let edits = editsByUri.get(edit.resource);
+                            if (!edits) {
+                                edits = [];
+                                editsByUri.set(edit.resource, edits);
+                            }
+                            edits.push(edit.textEdit);
+                        }
+                    }
+                    for (const [editUri, edits] of editsByUri) {
+                        chatModel.acceptResponseProgress(request, {
+                            kind: "textEdit",
+                            uri: editUri,
+                            edits: []
+                        });
+                        chatModel.acceptResponseProgress(request, {
+                            kind: "textEdit",
+                            uri: editUri,
+                            edits
+                        });
+                        chatModel.acceptResponseProgress(request, {
+                            kind: "textEdit",
+                            uri: editUri,
+                            edits: [],
+                            done: true
+                        });
+                    }
+                    return this._successResult(input, editsByUri.size, renameResult.edits.length);
+                }
+            }
+            await this._bulkEditService.apply(renameResult);
+            const fileCount = ( new ResourceSet(( renameResult.edits.filter(ResourceTextEdit.is).map(e => e.resource)))).size;
+            return this._successResult(input, fileCount, renameResult.edits.length);
+        } finally {
+            ref.dispose();
+        }
+    }
+    _successResult(input, fileCount, editCount) {
+        const text = editCount === 1 ? ( localize(
+            6463,
+            "Renamed `{0}` to `{1}` - 1 edit in {2} file.",
+            input.symbol,
+            input.newName,
+            fileCount
+        )) : ( localize(
+            6464,
+            "Renamed `{0}` to `{1}` - {2} edits across {3} files.",
+            input.symbol,
+            input.newName,
+            editCount,
+            fileCount
+        ));
+        const result = createToolSimpleTextResult(text);
+        result.toolResultMessage = ( new MarkdownString(text));
+        return result;
+    }
+};
+RenameTool = ( __decorate([( __param(0, ILanguageFeaturesService)), ( __param(1, ITextModelService)), ( __param(2, IWorkspaceContextService)), ( __param(3, IChatService)), ( __param(4, IBulkEditService))], RenameTool));
+let RenameToolContribution = class RenameToolContribution extends Disposable {
+    static {
+        this.ID = "chat.renameTool";
+    }
+    constructor(toolsService, instantiationService) {
+        super();
+        const renameTool = this._store.add(instantiationService.createInstance(RenameTool));
+        let registration;
+        const registerRenameTool = () => {
+            registration?.dispose();
+            toolsService.flushToolUpdates();
+            const toolData = renameTool.getToolData();
+            registration = toolsService.registerTool(toolData, renameTool);
+        };
+        registerRenameTool();
+        this._store.add(renameTool.onDidUpdateToolData(registerRenameTool));
+        this._store.add({
+            dispose: () => {
+                registration?.dispose();
+            }
+        });
+    }
+};
+RenameToolContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService))], RenameToolContribution));
+
+export { RenameTool, RenameToolContribution, RenameToolId };

package/vscode/src/vs/workbench/contrib/chat/browser/tools/toolHelpers.d.ts

@@ -0,0 +1,34 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IToolResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+export interface ISymbolToolInput {
+    symbol: string;
+    uri?: string;
+    filePath?: string;
+    lineContent: string;
+}
+/**
+ * Resolves a URI from tool input. Accepts either a full URI string or a
+ * workspace-relative file path.
+ */
+export declare function resolveToolUri(input: ISymbolToolInput, workspaceContextService: IWorkspaceContextService): URI | undefined;
+/**
+ * Finds the line number in the model that matches the given line content.
+ * Whitespace is normalized so that extra spaces in the input still match.
+ *
+ * @returns The 1-based line number, or `undefined` if not found.
+ */
+export declare function findLineNumber(model: ITextModel, lineContent: string): number | undefined;
+/**
+ * Finds the 1-based column of a symbol within a line of text using word
+ * boundary matching.
+ *
+ * @returns The 1-based column, or `undefined` if not found.
+ */
+export declare function findSymbolColumn(lineText: string, symbol: string): number | undefined;
+/**
+ * Creates an error tool result with the given message as both the content
+ * and the tool result message.
+ */
+export declare function errorResult(message: string): IToolResult;

package/vscode/src/vs/workbench/contrib/chat/browser/tools/toolHelpers.js

@@ -0,0 +1,45 @@
+
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { createToolSimpleTextResult } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/builtinTools/toolHelpers';
+
+function resolveToolUri(input, workspaceContextService) {
+    if (input.uri) {
+        return ( URI.parse(input.uri));
+    }
+    if (input.filePath) {
+        const folders = workspaceContextService.getWorkspace().folders;
+        if (folders.length === 1) {
+            return folders[0].toResource(input.filePath);
+        }
+        for (const folder of folders) {
+            return folder.toResource(input.filePath);
+        }
+    }
+    return undefined;
+}
+function findLineNumber(model, lineContent) {
+    const parts = lineContent.trim().split(/\s+/);
+    const pattern = ( parts.map(escapeRegExpCharacters)).join("\\s+");
+    const matches = model.findMatches(pattern, false, true, false, null, false, 1);
+    if (matches.length === 0) {
+        return undefined;
+    }
+    return matches[0].range.startLineNumber;
+}
+function findSymbolColumn(lineText, symbol) {
+    const pattern = ( new RegExp(`\\b${escapeRegExpCharacters(symbol)}\\b`));
+    const match = pattern.exec(lineText);
+    if (match) {
+        return match.index + 1;
+    }
+    return undefined;
+}
+function errorResult(message) {
+    const result = createToolSimpleTextResult(message);
+    result.toolResultMessage = ( new MarkdownString(message));
+    return result;
+}
+
+export { errorResult, findLineNumber, findSymbolColumn, resolveToolUri };

package/vscode/src/vs/workbench/contrib/chat/browser/tools/toolSetsContribution.js

@@ -44,7 +44,7 @@ const toolSetsSchema = {
     allowComments: true,
     allowTrailingCommas: true,
     defaultSnippets: [{
-        label: ( localize(5872, "Empty tool set")),
+        label: ( localize(6465, "Empty tool set")),
         body: {
             "${1:toolSetName}": {
                 "tools": ["${2:someTool}", "${3:anotherTool}"],
@@ -54,7 +54,7 @@ const toolSetsSchema = {
         }
     }],
     type: "object",
-    description: ( localize(5873, "User tool sets configuration")),
+    description: ( localize(6466, "User tool sets configuration")),
     additionalProperties: {
         type: "object",
         required: ["tools"],
@@ -62,7 +62,7 @@ const toolSetsSchema = {
         properties: {
             tools: {
                 description: ( localize(
-                    5874,
+                    6467,
                     "A list of tools or tool sets to include in this tool set. Cannot be empty and must reference tools the way they are referenced in prompts."
                 )),
                 type: "array",
@@ -75,7 +75,7 @@ const toolSetsSchema = {
             },
             icon: {
                 description: ( localize(
-                    5875,
+                    6468,
                     "Icon to use for this tool set in the UI. Uses the \"\\$(name)\"-syntax, like \"\\$(zap)\""
                 )),
                 type: "string",
@@ -83,7 +83,7 @@ const toolSetsSchema = {
                 markdownEnumDescriptions: Array.from(getAllCodicons(), icon => `$(${icon.id})`)
             },
             description: {
-                description: ( localize(5876, "A short description of this tool set.")),
+                description: ( localize(6469, "A short description of this tool set.")),
                 type: "string"
             }
         }
@@ -184,7 +184,7 @@ let UserToolSetsContributions = class UserToolSetsContributions extends Disposab
             });
             for (const item of data) {
                 toolEnumValues.push(item.name);
-                toolEnumDescriptions.push(( localize(5877, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
+                toolEnumDescriptions.push(( localize(6470, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
             }
             store.clear();
             reg.registerSchema(toolSetSchemaId, toolSetsSchema, store);
@@ -281,8 +281,8 @@ class ConfigureToolSets extends Action2 {
     constructor() {
         super({
             id: ConfigureToolSets.ID,
-            title: ( localize2(5878, "Configure Tool Sets...")),
-            shortTitle: ( localize(5879, "Tool Sets")),
+            title: ( localize2(6471, "Configure Tool Sets...")),
+            shortTitle: ( localize(6472, "Tool Sets")),
             category: CHAT_CATEGORY,
             f1: true,
             precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatContextKeys.Tools.toolsCount.greater(0))),
@@ -303,7 +303,7 @@ class ConfigureToolSets extends Action2 {
         const textFileService = accessor.get(ITextFileService);
         const picks = [];
         picks.push({
-            label: ( localize(5880, "Create new tool sets file...")),
+            label: ( localize(6473, "Create new tool sets file...")),
             alwaysShow: true,
             iconClass: ThemeIcon.asClassName(Codicon.plus)
         });
@@ -320,7 +320,7 @@ class ConfigureToolSets extends Action2 {
         }
         const pick = await quickInputService.pick(picks, {
             canPickMany: false,
-            placeHolder: ( localize(5881, "Select a tool set to configure"))
+            placeHolder: ( localize(6474, "Select a tool set to configure"))
         });
         if (!pick) {
             return;
@@ -328,13 +328,13 @@ class ConfigureToolSets extends Action2 {
         let resource;
         if (!pick.toolset) {
             const name = await quickInputService.input({
-                placeHolder: ( localize(5882, "Type tool sets file name")),
+                placeHolder: ( localize(6475, "Type tool sets file name")),
                 validateInput: async input => {
                     if (!input) {
-                        return localize(5883, "Invalid file name");
+                        return localize(6476, "Invalid file name");
                     }
                     if (!isValidBasename(input)) {
-                        return localize(5884, "'{0}' is not a valid file name", input);
+                        return localize(6477, "'{0}' is not a valid file name", input);
                     }
                     return undefined;
                 }

package/vscode/src/vs/workbench/contrib/chat/browser/tools/usagesTool.d.ts

@@ -0,0 +1,33 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+export declare const UsagesToolId = "vscode_listCodeUsages";
+export declare class UsagesTool extends Disposable implements IToolImpl {
+    private readonly _languageFeaturesService;
+    private readonly _modelService;
+    private readonly _searchService;
+    private readonly _textModelService;
+    private readonly _workspaceContextService;
+    private readonly _onDidUpdateToolData;
+    readonly onDidUpdateToolData: Event<void>;
+    constructor(_languageFeaturesService: ILanguageFeaturesService, _modelService: IModelService, _searchService: ISearchService, _textModelService: ITextModelService, _workspaceContextService: IWorkspaceContextService);
+    getToolData(): IToolData;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    private _getLinePreviews;
+    private _classifyReference;
+    private _overlaps;
+}
+export declare class UsagesToolContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "chat.usagesTool";
+    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService);
+}