@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/task/runTaskTool.js

@@ -15,9 +15,16 @@ import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codi
 import { toolResultDetailsFromResponse, toolResultMessageFromResponse } from './taskHelpers.js';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { TerminalToolId } from '../toolIds.js';
 
 let RunTaskTool = class RunTaskTool {
-    constructor(_tasksService, _telemetryService, _terminalService, _configurationService, _instantiationService) {
+    constructor(
+        _tasksService,
+        _telemetryService,
+        _terminalService,
+        _configurationService,
+        _instantiationService
+    ) {
         this._tasksService = _tasksService;
         this._telemetryService = _telemetryService;
         this._terminalService = _terminalService;
@@ -27,34 +34,85 @@ let RunTaskTool = class RunTaskTool {
     async invoke(invocation, _countTokens, _progress, token) {
         const args = invocation.parameters;
         if (!invocation.context) {
-            return { content: [{ kind: 'text', value: `No invocation context` }], toolResultMessage: `No invocation context` };
+            return {
+                content: [{
+                    kind: "text",
+                    value: `No invocation context`
+                }],
+                toolResultMessage: `No invocation context`
+            };
         }
         const taskDefinition = getTaskDefinition(args.id);
-        const task = await getTaskForTool(args.id, taskDefinition, args.workspaceFolder, this._configurationService, this._tasksService, true);
+        const task = await getTaskForTool(
+            args.id,
+            taskDefinition,
+            args.workspaceFolder,
+            this._configurationService,
+            this._tasksService,
+            true
+        );
         if (!task) {
-            return { content: [{ kind: 'text', value: `Task not found: ${args.id}` }], toolResultMessage: ( new MarkdownString(( localize(12082, 'Task not found: `{0}`', args.id)))) };
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Task not found: ${args.id}`
+                }],
+                toolResultMessage: ( new MarkdownString(( localize(12423, "Task not found: `{0}`", args.id))))
+            };
         }
         const taskLabel = task._label;
         const activeTasks = await this._tasksService.getActiveTasks();
         if (activeTasks.includes(task)) {
-            return { content: [{ kind: 'text', value: `The task ${taskLabel} is already running.` }], toolResultMessage: ( new MarkdownString(( localize(12083, 'The task `{0}` is already running.', taskLabel)))) };
+            return {
+                content: [{
+                    kind: "text",
+                    value: `The task ${taskLabel} is already running.`
+                }],
+                toolResultMessage: ( new MarkdownString(( localize(12424, "The task `{0}` is already running.", taskLabel))))
+            };
         }
-        const raceResult = await Promise.race([this._tasksService.run(task, undefined, TaskRunSource.ChatAgent), timeout(3000)]);
-        const result = raceResult && typeof raceResult === 'object' ? raceResult : undefined;
+        const raceResult = await Promise.race([
+            this._tasksService.run(task, undefined, TaskRunSource.ChatAgent),
+            timeout(3000)
+        ]);
+        const result = raceResult && typeof raceResult === "object" ? raceResult : undefined;
         const dependencyTasks = await resolveDependencyTasks(task, args.workspaceFolder, this._configurationService, this._tasksService);
         const resources = this._tasksService.getTerminalsForTasks(dependencyTasks ?? task);
         if (!resources || resources.length === 0) {
-            return { content: [{ kind: 'text', value: `Task started but no terminal was found for: ${taskLabel}` }], toolResultMessage: ( new MarkdownString(( localize(12084, 'Task started but no terminal was found for: `{0}`', taskLabel)))) };
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Task started but no terminal was found for: ${taskLabel}`
+                }],
+                toolResultMessage: ( new MarkdownString(( localize(12425, "Task started but no terminal was found for: `{0}`", taskLabel))))
+            };
         }
         const terminals = this._terminalService.instances.filter(t => ( resources.some(r => r.path === t.resource.path && r.scheme === t.resource.scheme)));
         if (terminals.length === 0) {
-            return { content: [{ kind: 'text', value: `Task started but no terminal was found for: ${taskLabel}` }], toolResultMessage: ( new MarkdownString(( localize(12084, 'Task started but no terminal was found for: `{0}`', taskLabel)))) };
+            return {
+                content: [{
+                    kind: "text",
+                    value: `Task started but no terminal was found for: ${taskLabel}`
+                }],
+                toolResultMessage: ( new MarkdownString(( localize(12425, "Task started but no terminal was found for: `{0}`", taskLabel))))
+            };
         }
         const store = ( new DisposableStore());
-        const terminalResults = await collectTerminalResults(terminals, task, this._instantiationService, invocation.context, _progress, token, store, (terminalTask) => this._isTaskActive(terminalTask), dependencyTasks, this._tasksService);
+        const terminalResults = await collectTerminalResults(
+            terminals,
+            task,
+            this._instantiationService,
+            invocation.context,
+            _progress,
+            token,
+            store,
+            terminalTask => this._isTaskActive(terminalTask),
+            dependencyTasks,
+            this._tasksService
+        );
         store.dispose();
         for (const r of terminalResults) {
-            this._telemetryService.publicLog2?.('copilotChat.runTaskTool.run', {
+            this._telemetryService.publicLog2?.("copilotChat.runTaskTool.run", {
                 taskId: args.id,
                 bufferLength: r.output.length ?? 0,
                 pollDurationMs: r.pollDurationMs ?? 0,
@@ -67,11 +125,21 @@ let RunTaskTool = class RunTaskTool {
             });
         }
         const details = ( terminalResults.map(r => `Terminal: ${r.name}\nOutput:\n${r.output}`));
-        const uniqueDetails = Array.from(( new Set(details))).join('\n\n');
+        const uniqueDetails = Array.from(( new Set(details))).join("\n\n");
         const toolResultDetails = toolResultDetailsFromResponse(terminalResults);
-        const toolResultMessage = toolResultMessageFromResponse(result, taskLabel, toolResultDetails, terminalResults, undefined, task.configurationProperties.isBackground);
+        const toolResultMessage = toolResultMessageFromResponse(
+            result,
+            taskLabel,
+            toolResultDetails,
+            terminalResults,
+            undefined,
+            task.configurationProperties.isBackground
+        );
         return {
-            content: [{ kind: 'text', value: uniqueDetails }],
+            content: [{
+                kind: "text",
+                value: uniqueDetails
+            }],
             toolResultMessage,
             toolResultDetails
         };
@@ -83,66 +151,67 @@ let RunTaskTool = class RunTaskTool {
     async prepareToolInvocation(context, token) {
         const args = context.parameters;
         const taskDefinition = getTaskDefinition(args.id);
-        const task = await getTaskForTool(args.id, taskDefinition, args.workspaceFolder, this._configurationService, this._tasksService, true);
+        const task = await getTaskForTool(
+            args.id,
+            taskDefinition,
+            args.workspaceFolder,
+            this._configurationService,
+            this._tasksService,
+            true
+        );
         if (!task) {
-            return { invocationMessage: ( new MarkdownString(( localize(12082, 'Task not found: `{0}`', args.id)))) };
+            return {
+                invocationMessage: ( new MarkdownString(( localize(12423, "Task not found: `{0}`", args.id))))
+            };
         }
         const taskLabel = task._label;
         const activeTasks = await this._tasksService.getActiveTasks();
         if (task && activeTasks.includes(task)) {
-            return { invocationMessage: ( new MarkdownString(( localize(12085, 'The task is already running.')))) };
+            return {
+                invocationMessage: ( new MarkdownString(( localize(12426, "The task is already running."))))
+            };
         }
         if (await this._isTaskActive(task)) {
             return {
-                invocationMessage: ( new MarkdownString(( localize(12086, '`{0}` is already running.', taskLabel)))),
-                pastTenseMessage: ( new MarkdownString(( localize(12087, '`{0}` was already running.', taskLabel)))),
+                invocationMessage: ( new MarkdownString(( localize(12427, "`{0}` is already running.", taskLabel)))),
+                pastTenseMessage: ( new MarkdownString(( localize(12428, "`{0}` was already running.", taskLabel)))),
                 confirmationMessages: undefined
             };
         }
         return {
-            invocationMessage: ( new MarkdownString(( localize(12088, 'Running `{0}`', taskLabel)))),
-            pastTenseMessage: ( new MarkdownString(task?.configurationProperties.isBackground
-                ? ( localize(12089, 'Started `{0}`', taskLabel))
-                : ( localize(12090, 'Ran `{0}`', taskLabel)))),
-            confirmationMessages: task
-                ? { title: ( localize(12091, 'Allow task run?')), message: ( localize(12092, 'Allow to run the task `{0}`?', taskLabel)) }
-                : undefined
+            invocationMessage: ( new MarkdownString(( localize(12429, "Running `{0}`", taskLabel)))),
+            pastTenseMessage: ( new MarkdownString(task?.configurationProperties.isBackground ? ( localize(12430, "Started `{0}`", taskLabel)) : ( localize(12431, "Ran `{0}`", taskLabel)))),
+            confirmationMessages: task ? {
+                title: ( localize(12432, "Allow task run?")),
+                message: ( localize(12433, "Allow to run the task `{0}`?", taskLabel))
+            } : undefined
         };
     }
 };
-RunTaskTool = ( __decorate([
-    ( __param(0, ITaskService)),
-    ( __param(1, ITelemetryService)),
-    ( __param(2, ITerminalService)),
-    ( __param(3, IConfigurationService)),
-    ( __param(4, IInstantiationService))
-], RunTaskTool));
+RunTaskTool = ( __decorate([( __param(0, ITaskService)), ( __param(1, ITelemetryService)), ( __param(2, ITerminalService)), ( __param(3, IConfigurationService)), ( __param(4, IInstantiationService))], RunTaskTool));
 const RunTaskToolData = {
-    id: 'run_task',
-    toolReferenceName: 'runTask',
-    legacyToolReferenceFullNames: ['runTasks/runTask'],
-    displayName: ( localize(12093, 'Run Task')),
-    modelDescription: 'Runs a VS Code task.\n\n- If you see that an appropriate task exists for building or running code, prefer to use this tool to run the task instead of using the run_in_terminal tool.\n- Make sure that any appropriate build or watch task is running before trying to run tests or execute code.\n- If the user asks to run a task, use this tool to do so.',
-    userDescription: ( localize(12094, 'Run tasks in the workspace')),
+    id: TerminalToolId.RunTask,
+    toolReferenceName: "runTask",
+    legacyToolReferenceFullNames: ["runTasks/runTask"],
+    displayName: ( localize(12434, "Run Task")),
+    modelDescription: `Runs a VS Code task.\n\n- If you see that an appropriate task exists for building or running code, prefer to use this tool to run the task instead of using the ${TerminalToolId.RunInTerminal} tool.\n- Make sure that any appropriate build or watch task is running before trying to run tests or execute code.\n- If the user asks to run a task, use this tool to do so.`,
+    userDescription: ( localize(12435, "Run tasks in the workspace")),
     icon: Codicon.tools,
     source: ToolDataSource.Internal,
     when: TasksAvailableContext,
     inputSchema: {
-        'type': 'object',
-        'properties': {
-            'workspaceFolder': {
-                'type': 'string',
-                'description': 'The workspace folder path containing the task'
+        "type": "object",
+        "properties": {
+            "workspaceFolder": {
+                "type": "string",
+                "description": "The workspace folder path containing the task"
             },
-            'id': {
-                'type': 'string',
-                'description': 'The task ID to run.'
+            "id": {
+                "type": "string",
+                "description": "The task ID to run."
             }
         },
-        'required': [
-            'workspaceFolder',
-            'id'
-        ]
+        "required": ["workspaceFolder", "id"]
     }
 };
 

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/task/taskHelpers.js

@@ -4,42 +4,39 @@ import { OutputMonitorState } from '../monitoring/types.js';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 
 function toolResultDetailsFromResponse(terminalResults) {
-    return Array.from(( ( new Map(terminalResults
-        .flatMap(r => r.resources?.filter(res => res.uri).map(res => {
-        const range = res.range;
-        const item = range !== undefined ? { uri: res.uri, range } : res.uri;
-        const key = range !== undefined
-            ? `${( res.uri.toString())}-${( range.toString())}`
-            : `${( res.uri.toString())}`;
-        return [key, item];
-    }) ?? []))).values()));
+    return Array.from(( ( new Map(
+        terminalResults.flatMap(r => r.resources?.filter(res => res.uri).map(res => {
+            const range = res.range;
+            const item = range !== undefined ? {
+                uri: res.uri,
+                range
+            } : res.uri;
+            const key = range !== undefined ? `${( res.uri.toString())}-${( range.toString())}` : `${( res.uri.toString())}`;
+            return [key, item];
+        }) ?? [])
+    )).values()));
 }
-function toolResultMessageFromResponse(result, taskLabel, toolResultDetails, terminalResults, getOutputTool, isBackground) {
-    let resultSummary = '';
+function toolResultMessageFromResponse(
+    result,
+    taskLabel,
+    toolResultDetails,
+    terminalResults,
+    getOutputTool,
+    isBackground
+) {
+    let resultSummary = "";
     if (result?.exitCode) {
-        resultSummary = ( localize(12095, 'Task `{0}` failed with exit code {1}.', taskLabel, result.exitCode));
-    }
-    else {
+        resultSummary = ( localize(12436, "Task `{0}` failed with exit code {1}.", taskLabel, result.exitCode));
+    } else {
         resultSummary += `\`${taskLabel}\` task `;
         const problemCount = toolResultDetails.length;
         if (getOutputTool) {
             return problemCount ? ( new MarkdownString(
-                `Got output for ${resultSummary} with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
+                `Got output for ${resultSummary} with \`${problemCount}\` problem${problemCount === 1 ? "" : "s"}`
             )) : ( new MarkdownString(`Got output for ${resultSummary}`));
-        }
-        else {
+        } else {
             const problemCount = toolResultDetails.length;
-            resultSummary += terminalResults.every(r => r.state === OutputMonitorState.Idle)
-                ? (problemCount
-                    ? `finished with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
-                    : 'finished')
-                : (isBackground
-                    ? (problemCount
-                        ? `started and will continue to run in the background with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
-                        : 'started and will continue to run in the background')
-                    : (problemCount
-                        ? `started with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
-                        : 'started'));
+            resultSummary += terminalResults.every(r => r.state === OutputMonitorState.Idle) ? (problemCount ? `finished with \`${problemCount}\` problem${problemCount === 1 ? "" : "s"}` : "finished") : (isBackground ? (problemCount ? `started and will continue to run in the background with \`${problemCount}\` problem${problemCount === 1 ? "" : "s"}` : "started and will continue to run in the background") : (problemCount ? `started with \`${problemCount}\` problem${problemCount === 1 ? "" : "s"}` : "started"));
         }
     }
     return ( new MarkdownString(resultSummary));

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/terminalCommandArtifactCollector.d.ts

@@ -6,6 +6,11 @@ export declare class TerminalCommandArtifactCollector {
     constructor(_logService: ITerminalLogService);
     capture(toolSpecificData: IChatTerminalToolInvocationData, instance: ITerminalInstance, commandId: string | undefined): Promise<void>;
     private _captureCommandOutput;
+    /**
+     * Captures output from a partial/current command that hasn't finished yet.
+     * This is used when the command is cancelled mid-execution.
+     */
+    private _capturePartialCommandOutput;
     private _applyTheme;
     private _createTerminalCommandUri;
     private _tryGetCommand;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/terminalCommandArtifactCollector.js

@@ -12,9 +12,11 @@ let TerminalCommandArtifactCollector = class TerminalCommandArtifactCollector {
         if (commandId) {
             try {
                 toolSpecificData.terminalCommandUri = this._createTerminalCommandUri(instance, commandId);
-            }
-            catch (error) {
-                this._logService.warn(`RunInTerminalTool: Failed to create terminal command URI for ${commandId}`, error);
+            } catch (error) {
+                this._logService.warn(
+                    `RunInTerminalTool: Failed to create terminal command URI for ${commandId}`,
+                    error
+                );
             }
             const command = await this._tryGetCommand(instance, commandId);
             if (command) {
@@ -30,14 +32,18 @@ let TerminalCommandArtifactCollector = class TerminalCommandArtifactCollector {
                 this._applyTheme(toolSpecificData, instance);
                 return;
             }
+            const partialSnapshot = await this._capturePartialCommandOutput(instance, commandId);
+            if (partialSnapshot) {
+                toolSpecificData.terminalCommandOutput = partialSnapshot;
+                this._logService.debug(`RunInTerminalTool: Captured partial command output for ${commandId}`);
+            }
         }
         this._applyTheme(toolSpecificData, instance);
     }
     async _captureCommandOutput(instance, command) {
         try {
             await instance.xtermReadyPromise;
-        }
-        catch {
+        } catch {
             return undefined;
         }
         const xterm = instance.xterm;
@@ -45,28 +51,68 @@ let TerminalCommandArtifactCollector = class TerminalCommandArtifactCollector {
             return undefined;
         }
         return getCommandOutputSnapshot(xterm, command, (reason, error) => {
-            const suffix = reason === 'fallback' ? ' (fallback)' : '';
+            const suffix = reason === "fallback" ? " (fallback)" : "";
             this._logService.debug(`RunInTerminalTool: Failed to snapshot command output${suffix}`, error);
         });
     }
+    async _capturePartialCommandOutput(instance, commandId) {
+        try {
+            await instance.xtermReadyPromise;
+        } catch {
+            return undefined;
+        }
+        const xterm = instance.xterm;
+        if (!xterm) {
+            return undefined;
+        }
+        const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
+        const currentCommand = commandDetection?.currentCommand;
+        if (currentCommand && currentCommand.id === commandId) {
+            const executedMarker = currentCommand.commandExecutedMarker;
+            if (executedMarker && !executedMarker.isDisposed) {
+                try {
+                    const raw = xterm.raw;
+                    const buffer = raw.buffer.active;
+                    const endLine = buffer.baseY + buffer.cursorY;
+                    const startLine = executedMarker.line;
+                    const lineCount = Math.max(endLine - startLine, 0);
+                    if (lineCount > 0) {
+                        const text = await xterm.getRangeAsVT(executedMarker, undefined, true);
+                        if (text) {
+                            return {
+                                text,
+                                lineCount
+                            };
+                        }
+                    }
+                } catch (error) {
+                    this._logService.debug(`RunInTerminalTool: Failed to capture partial command output`, error);
+                }
+            }
+        }
+        return undefined;
+    }
     _applyTheme(toolSpecificData, instance) {
         const theme = instance.xterm?.getXtermTheme();
         if (theme) {
-            toolSpecificData.terminalTheme = { background: theme.background, foreground: theme.foreground };
+            toolSpecificData.terminalTheme = {
+                background: theme.background,
+                foreground: theme.foreground
+            };
         }
     }
     _createTerminalCommandUri(instance, commandId) {
         const params = ( new URLSearchParams(instance.resource.query));
-        params.set('command', commandId);
-        return instance.resource.with({ query: ( params.toString()) });
+        params.set("command", commandId);
+        return instance.resource.with({
+            query: ( params.toString())
+        });
     }
     async _tryGetCommand(instance, commandId) {
         const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
         return commandDetection?.commands.find(c => c.id === commandId);
     }
 };
-TerminalCommandArtifactCollector = ( __decorate([
-    ( __param(0, ITerminalLogService))
-], TerminalCommandArtifactCollector));
+TerminalCommandArtifactCollector = ( __decorate([( __param(0, ITerminalLogService))], TerminalCommandArtifactCollector));
 
 export { TerminalCommandArtifactCollector };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/toolIds.d.ts

@@ -0,0 +1,12 @@
+export declare enum TerminalToolId {
+    RunInTerminal = "run_in_terminal",
+    AwaitTerminal = "await_terminal",
+    GetTerminalOutput = "get_terminal_output",
+    KillTerminal = "kill_terminal",
+    TerminalSelection = "terminal_selection",
+    TerminalLastCommand = "terminal_last_command",
+    ConfirmTerminalCommand = "vscode_get_terminal_confirmation",
+    CreateAndRunTask = "create_and_run_task",
+    GetTaskOutput = "get_task_output",
+    RunTask = "run_task"
+}

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/toolIds.js

@@ -0,0 +1,17 @@
+
+
+var TerminalToolId;
+(function (TerminalToolId) {
+    TerminalToolId["RunInTerminal"] = "run_in_terminal";
+    TerminalToolId["AwaitTerminal"] = "await_terminal";
+    TerminalToolId["GetTerminalOutput"] = "get_terminal_output";
+    TerminalToolId["KillTerminal"] = "kill_terminal";
+    TerminalToolId["TerminalSelection"] = "terminal_selection";
+    TerminalToolId["TerminalLastCommand"] = "terminal_last_command";
+    TerminalToolId["ConfirmTerminalCommand"] = "vscode_get_terminal_confirmation";
+    TerminalToolId["CreateAndRunTask"] = "create_and_run_task";
+    TerminalToolId["GetTaskOutput"] = "get_task_output";
+    TerminalToolId["RunTask"] = "run_task";
+})(TerminalToolId || (TerminalToolId = {}));
+
+export { TerminalToolId };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/treeSitterCommandParser.d.ts

@@ -1,4 +1,4 @@
-import type { QueryCapture } from "@vscode/tree-sitter-wasm";
+import type { QueryCapture } from "@codingame/monaco-vscode-api/external/@vscode/tree-sitter-wasm/wasm/tree-sitter";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { ITreeSitterLibraryService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterLibraryService.service";
 export declare enum TreeSitterCommandParserLanguage {
@@ -9,10 +9,17 @@ export declare class TreeSitterCommandParser extends Disposable {
     private readonly _treeSitterLibraryService;
     private readonly _parser;
     private readonly _treeCache;
+    private readonly _commandFileWriteParsers;
     constructor(_treeSitterLibraryService: ITreeSitterLibraryService);
     extractSubCommands(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
     extractPwshDoubleAmpersandChainOperators(commandLine: string): Promise<QueryCapture[]>;
     getFileWrites(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
+    /**
+     * Extracts file targets from commands that perform file writes beyond shell redirections.
+     * Uses registered command parsers (e.g., for `sed -i`) to detect command-specific file writes.
+     * Returns an array of file paths that would be modified.
+     */
+    getCommandFileWrites(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
     private _queryTree;
     private _doQuery;
 }

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/treeSitterCommandParser.js

@@ -5,9 +5,10 @@ import { BugIndicatingError, ErrorNoTelemetry } from '@codingame/monaco-vscode-a
 import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
 import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ITreeSitterLibraryService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterLibraryService.service';
+import { SedFileWriteParser } from './commandParsers/sedFileWriteParser.js';
 
 var TreeSitterCommandParserLanguage;
-(function (TreeSitterCommandParserLanguage) {
+(function(TreeSitterCommandParserLanguage) {
     TreeSitterCommandParserLanguage["Bash"] = "bash";
     TreeSitterCommandParserLanguage["PowerShell"] = "powershell";
 })(TreeSitterCommandParserLanguage || (TreeSitterCommandParserLanguage = {}));
@@ -16,50 +17,67 @@ let TreeSitterCommandParser = class TreeSitterCommandParser extends Disposable {
         super();
         this._treeSitterLibraryService = _treeSitterLibraryService;
         this._treeCache = this._register(( new TreeCache()));
+        this._commandFileWriteParsers = [( new SedFileWriteParser())];
         this._parser = ( new Lazy(
             () => this._treeSitterLibraryService.getParserClass().then(ParserCtor => ( new ParserCtor()))
         ));
     }
     async extractSubCommands(languageId, commandLine) {
-        const captures = await this._queryTree(languageId, commandLine, '(command) @command');
+        const captures = await this._queryTree(languageId, commandLine, "(command) @command");
         return ( captures.map(e => e.node.text));
     }
     async extractPwshDoubleAmpersandChainOperators(commandLine) {
-        const captures = await this._queryTree(TreeSitterCommandParserLanguage.PowerShell, commandLine, [
-            '(',
-            '  (pipeline',
-            '    (pipeline_chain_tail) @double.ampersand)',
-            ')',
-        ].join('\n'));
+        const captures = await this._queryTree(
+            TreeSitterCommandParserLanguage.PowerShell,
+            commandLine,
+            ["(", "  (pipeline", "    (pipeline_chain_tail) @double.ampersand)", ")"].join("\n")
+        );
         return captures;
     }
     async getFileWrites(languageId, commandLine) {
         let query;
         switch (languageId) {
-            case TreeSitterCommandParserLanguage.Bash:
-                query = [
-                    '(file_redirect',
-                    '  destination: [(word) (string (string_content)) (raw_string) (concatenation)] @file)',
-                ].join('\n');
-                break;
-            case TreeSitterCommandParserLanguage.PowerShell:
-                query = [
-                    '(redirection',
-                    '  (redirected_file_name) @file)',
-                ].join('\n');
-                break;
+        case TreeSitterCommandParserLanguage.Bash:
+            query = [
+                "(file_redirect",
+                "  destination: [(word) (string (string_content)) (raw_string) (concatenation)] @file)"
+            ].join("\n");
+            break;
+        case TreeSitterCommandParserLanguage.PowerShell:
+            query = ["(redirection", "  (redirected_file_name) @file)"].join("\n");
+            break;
         }
         const captures = await this._queryTree(languageId, commandLine, query);
         return ( captures.map(e => e.node.text.trim()));
     }
+    async getCommandFileWrites(languageId, commandLine) {
+        if (languageId !== TreeSitterCommandParserLanguage.Bash) {
+            return [];
+        }
+        const query = "(command) @command";
+        const captures = await this._queryTree(languageId, commandLine, query);
+        const result = [];
+        for (const capture of captures) {
+            const commandText = capture.node.text;
+            for (const parser of this._commandFileWriteParsers) {
+                if (parser.canHandle(commandText)) {
+                    result.push(...parser.extractFileWrites(commandText));
+                }
+            }
+        }
+        return result;
+    }
     async _queryTree(languageId, commandLine, querySource) {
-        const { tree, query } = await this._doQuery(languageId, commandLine, querySource);
+        const {
+            tree,
+            query
+        } = await this._doQuery(languageId, commandLine, querySource);
         return query.captures(tree.rootNode);
     }
     async _doQuery(languageId, commandLine, querySource) {
         const language = await this._treeSitterLibraryService.getLanguagePromise(languageId);
         if (!language) {
-            throw ( new BugIndicatingError('Failed to fetch language grammar'));
+            throw ( new BugIndicatingError("Failed to fetch language grammar"));
         }
         let tree = this._treeCache.get(languageId, commandLine);
         if (!tree) {
@@ -67,21 +85,22 @@ let TreeSitterCommandParser = class TreeSitterCommandParser extends Disposable {
             parser.setLanguage(language);
             const parsedTree = parser.parse(commandLine);
             if (!parsedTree) {
-                throw ( new ErrorNoTelemetry('Failed to parse tree'));
+                throw ( new ErrorNoTelemetry("Failed to parse tree"));
             }
             tree = parsedTree;
             this._treeCache.set(languageId, commandLine, tree);
         }
         const query = await this._treeSitterLibraryService.createQuery(language, querySource);
         if (!query) {
-            throw ( new BugIndicatingError('Failed to create tree sitter query'));
+            throw ( new BugIndicatingError("Failed to create tree sitter query"));
         }
-        return { tree, query };
+        return {
+            tree,
+            query
+        };
     }
 };
-TreeSitterCommandParser = ( __decorate([
-    ( __param(0, ITreeSitterLibraryService))
-], TreeSitterCommandParser));
+TreeSitterCommandParser = ( __decorate([( __param(0, ITreeSitterLibraryService))], TreeSitterCommandParser));
 class TreeCache extends Disposable {
     constructor() {
         super();