@codingame/monaco-vscode-chat-service-override 22.1.8 → 23.0.0

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

@@ -100,12 +100,40 @@ async function collectTerminalResults(terminals, task, instantiationService, inv
     if (token.isCancellationRequested) {
         return results;
     }
+    const commonTaskIdToTaskMap = {};
+    const taskIdToTaskMap = {};
+    const taskLabelToTaskMap = {};
+    for (const dependencyTask of dependencyTasks ?? []) {
+        commonTaskIdToTaskMap[dependencyTask.getCommonTaskId()] = dependencyTask;
+        taskIdToTaskMap[dependencyTask._id] = dependencyTask;
+        taskLabelToTaskMap[dependencyTask._label] = dependencyTask;
+    }
     for (const instance of terminals) {
         progress.report({ message: ( new MarkdownString(`Checking output for \`${instance.shellLaunchConfig.name ?? 'unknown'}\``)) });
+        let terminalTask = task;
+        if (dependencyTasks?.length) {
+            const reconnectionData = instance.reconnectionProperties?.data;
+            if (reconnectionData) {
+                if (reconnectionData.lastTask in commonTaskIdToTaskMap) {
+                    terminalTask = commonTaskIdToTaskMap[reconnectionData.lastTask];
+                }
+                else if (reconnectionData.id in taskIdToTaskMap) {
+                    terminalTask = taskIdToTaskMap[reconnectionData.id];
+                }
+            }
+            else {
+                if (instance.shellLaunchConfig.name && instance.shellLaunchConfig.name in taskLabelToTaskMap) {
+                    terminalTask = taskLabelToTaskMap[instance.shellLaunchConfig.name];
+                }
+                else if (instance.title in taskLabelToTaskMap) {
+                    terminalTask = taskLabelToTaskMap[instance.title];
+                }
+            }
+        }
         const execution = {
             getOutput: () => getOutput(instance) ?? '',
-            isActive,
-            task,
+            task: terminalTask,
+            isActive: isActive ? () => isActive(terminalTask) : undefined,
             instance,
             dependencyTasks,
             sessionId: invocationContext.sessionId
@@ -114,7 +142,7 @@ async function collectTerminalResults(terminals, task, instantiationService, inv
         await Event.toPromise(outputMonitor.onDidFinishCommand);
         const pollingResult = outputMonitor.pollingResult;
         results.push({
-            name: instance.shellLaunchConfig.name ?? 'unknown',
+            name: instance.shellLaunchConfig.name ?? instance.title ?? 'unknown',
             output: pollingResult?.output ?? '',
             pollDurationMs: pollingResult?.pollDurationMs ?? 0,
             resources: pollingResult?.resources,
@@ -160,9 +188,10 @@ async function taskProblemPollFn(execution, token, taskService) {
                 }
             }
             if (problemList.length === 0) {
+                const lastTenLines = execution.getOutput().split('\n').filter(line => line !== '').slice(-10).join('\n');
                 return {
                     state: OutputMonitorState.Idle,
-                    output: 'The task succeeded with no problems.',
+                    output: `Task completed with output:\n${lastTenLines}`,
                 };
             }
             return {

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

@@ -3,43 +3,71 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 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 { TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
 import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
 import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
-import { showChatView } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { showChatView } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ToolDataSource, VSCodeToolReference } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
 import { registerActiveInstanceAction, sharedWhenClause } from '@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/workbench/contrib/terminal/browser/terminalActions';
 import { TerminalContextMenuGroup } from '@codingame/monaco-vscode-05a2a821-e4de-5941-b7f9-bbf01c09f229-common/vscode/vs/workbench/contrib/terminal/browser/terminalMenus';
 import { TerminalContextKeys } from '@codingame/monaco-vscode-b6d52a6d-8c8e-51f5-bcd2-1722295e31d9-common/vscode/vs/workbench/contrib/terminal/common/terminalContextKey';
 import { TerminalChatAgentToolsCommandId } from '../common/terminal.chatAgentTools.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-de235d7f-e72a-5adb-9256-acf6c64eb6f2-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
 import { GetTerminalLastCommandTool, GetTerminalLastCommandToolData } from './tools/getTerminalLastCommandTool.js';
 import { GetTerminalOutputTool, GetTerminalOutputToolData } from './tools/getTerminalOutputTool.js';
 import { GetTerminalSelectionTool, GetTerminalSelectionToolData } from './tools/getTerminalSelectionTool.js';
-import { RunInTerminalTool, RunInTerminalToolData } from './tools/runInTerminalTool.js';
+import { ConfirmTerminalCommandTool, ConfirmTerminalCommandToolData } from './tools/runInTerminalConfirmationTool.js';
+import { createRunInTerminalToolData, RunInTerminalTool } from './tools/runInTerminalTool.js';
 import { CreateAndRunTaskTool, CreateAndRunTaskToolData } from './tools/task/createAndRunTaskTool.js';
 import { GetTaskOutputTool, GetTaskOutputToolData } from './tools/task/getTaskOutputTool.js';
 import { RunTaskTool, RunTaskToolData } from './tools/task/runTaskTool.js';
 
+let ShellIntegrationTimeoutMigrationContribution = class ShellIntegrationTimeoutMigrationContribution extends Disposable {
+    static { this.ID = 'terminal.shellIntegrationTimeoutMigration'; }
+    constructor(configurationService) {
+        super();
+        const deprecatedSettingValue = configurationService.getValue(TerminalChatAgentToolsSettingId.ShellIntegrationTimeout);
+        if (!isNumber(deprecatedSettingValue)) {
+            return;
+        }
+        const newSettingValue = configurationService.getValue(TerminalSettingId.ShellIntegrationTimeout);
+        if (!isNumber(newSettingValue)) {
+            configurationService.updateValue(TerminalSettingId.ShellIntegrationTimeout, deprecatedSettingValue);
+        }
+    }
+};
+ShellIntegrationTimeoutMigrationContribution = ( __decorate([
+    ( __param(0, IConfigurationService))
+], ShellIntegrationTimeoutMigrationContribution));
+registerWorkbenchContribution2(ShellIntegrationTimeoutMigrationContribution.ID, ShellIntegrationTimeoutMigrationContribution, WorkbenchPhase.Eventually);
 let ChatAgentToolsContribution = class ChatAgentToolsContribution extends Disposable {
     static { this.ID = 'terminal.chatAgentTools'; }
     constructor(instantiationService, toolsService) {
         super();
-        const runInTerminalTool = instantiationService.createInstance(RunInTerminalTool);
-        this._register(toolsService.registerTool(RunInTerminalToolData, runInTerminalTool));
+        const confirmTerminalCommandTool = instantiationService.createInstance(ConfirmTerminalCommandTool);
+        this._register(toolsService.registerTool(ConfirmTerminalCommandToolData, confirmTerminalCommandTool));
         const getTerminalOutputTool = instantiationService.createInstance(GetTerminalOutputTool);
         this._register(toolsService.registerTool(GetTerminalOutputToolData, getTerminalOutputTool));
-        const runCommandsToolSet = this._register(toolsService.createToolSet(ToolDataSource.Internal, 'runCommands', 'runCommands', {
+        const runCommandsToolSet = this._register(toolsService.createToolSet(ToolDataSource.Internal, 'runCommands', VSCodeToolReference.runCommands, {
             icon: ThemeIcon.fromId(Codicon.terminal.id),
-            description: ( localize(11544, 'Runs commands in the terminal'))
+            description: ( localize(11831, 'Runs commands in the terminal'))
         }));
-        runCommandsToolSet.addTool(RunInTerminalToolData);
         runCommandsToolSet.addTool(GetTerminalOutputToolData);
+        instantiationService.invokeFunction(createRunInTerminalToolData).then(runInTerminalToolData => {
+            const runInTerminalTool = instantiationService.createInstance(RunInTerminalTool);
+            this._register(toolsService.registerTool(runInTerminalToolData, runInTerminalTool));
+            runCommandsToolSet.addTool(runInTerminalToolData);
+        });
         const getTerminalSelectionTool = instantiationService.createInstance(GetTerminalSelectionTool);
         this._register(toolsService.registerTool(GetTerminalSelectionToolData, getTerminalSelectionTool));
         const getTerminalLastCommandTool = instantiationService.createInstance(GetTerminalLastCommandTool);
@@ -53,7 +81,7 @@ let ChatAgentToolsContribution = class ChatAgentToolsContribution extends Dispos
         const createAndRunTaskTool = instantiationService.createInstance(CreateAndRunTaskTool);
         this._register(toolsService.registerTool(CreateAndRunTaskToolData, createAndRunTaskTool));
         const runTasksToolSet = this._register(toolsService.createToolSet(ToolDataSource.Internal, 'runTasks', 'runTasks', {
-            description: ( localize(11545, 'Runs tasks and gets their output for your workspace')),
+            description: ( localize(11832, 'Runs tasks and gets their output for your workspace')),
         }));
         runTasksToolSet.addTool(RunTaskToolData);
         runTasksToolSet.addTool(GetTaskOutputToolData);
@@ -67,7 +95,7 @@ ChatAgentToolsContribution = ( __decorate([
 registerWorkbenchContribution2(ChatAgentToolsContribution.ID, ChatAgentToolsContribution, WorkbenchPhase.AfterRestored);
 registerActiveInstanceAction({
     id: TerminalChatAgentToolsCommandId.ChatAddTerminalSelection,
-    title: ( localize(11546, 'Add Terminal Selection to Chat')),
+    title: ( localize(11833, 'Add Terminal Selection to Chat')),
     precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, sharedWhenClause.terminalAvailable)),
     menu: [
         {
@@ -80,19 +108,20 @@ registerActiveInstanceAction({
     run: async (activeInstance, _c, accessor) => {
         const viewsService = accessor.get(IViewsService);
         const chatWidgetService = accessor.get(IChatWidgetService);
+        const layoutService = accessor.get(IWorkbenchLayoutService);
         const selection = activeInstance.selection;
         if (!selection) {
             return;
         }
-        const chatView = chatWidgetService.lastFocusedWidget || (await showChatView(viewsService));
+        const chatView = chatWidgetService.lastFocusedWidget || (await showChatView(viewsService, layoutService));
         if (!chatView) {
             return;
         }
         chatView.attachmentModel.addContext({
             id: `terminal-selection-${Date.now()}`,
             kind: 'generic',
-            name: ( localize(11547, 'Terminal Selection')),
-            fullName: ( localize(11547, 'Terminal Selection')),
+            name: ( localize(11834, 'Terminal Selection')),
+            fullName: ( localize(11834, 'Terminal Selection')),
             value: selection,
             icon: Codicon.terminal
         });

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

@@ -8,12 +8,12 @@ import { DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { isNumber, isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { TerminalCapability } from '@codingame/monaco-vscode-a9da9abe-278d-5ce6-9418-99c7c07c5c37-common/vscode/vs/platform/terminal/common/capabilities/capabilities';
-import { PromptInputState } from '@codingame/monaco-vscode-88141f48-1af9-57ef-a278-f4b2ff6128fa-common/vscode/vs/platform/terminal/common/capabilities/commandDetection/promptInputModel';
+import { TerminalCapability } from '@codingame/monaco-vscode-10af0e5d-64cb-56de-b584-29ab4a355d15-common/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { PromptInputState } from '@codingame/monaco-vscode-45e04ac3-b807-5ae5-8818-7b9c40b6d31f-common/vscode/vs/platform/terminal/common/capabilities/commandDetection/promptInputModel';
 import { TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
-import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-a175bd1a-4858-5944-9ae5-fb73305dcb13-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { getShellIntegrationTimeout } from '@codingame/monaco-vscode-07eaa805-9dea-5ec6-a422-a4f04872424d-common/vscode/vs/workbench/contrib/terminal/common/terminalEnvironment';
 
 var ToolTerminalCreator_1;
 var ShellLaunchType;
@@ -42,22 +42,16 @@ let ToolTerminalCreator = class ToolTerminalCreator {
             instance,
             shellIntegrationQuality: ShellIntegrationQuality.None,
         };
+        let processReadyTimestamp = 0;
         const initResult = await Promise.any([
-            instance.processReady,
+            instance.processReady.then(() => processReadyTimestamp = Date.now()),
             Event.toPromise(instance.onExit),
         ]);
         if (!isNumber(initResult) && isObject(initResult) && 'message' in initResult) {
             throw ( new Error(initResult.message));
         }
-        const siInjectionEnabled = this._configurationService.getValue(TerminalSettingId.ShellIntegrationEnabled);
-        const configuredTimeout = this._configurationService.getValue(TerminalChatAgentToolsSettingId.ShellIntegrationTimeout);
-        let waitTime;
-        if (configuredTimeout === undefined || typeof configuredTimeout !== 'number' || configuredTimeout < 0) {
-            waitTime = siInjectionEnabled ? 5000 : (instance.isRemote ? 3000 : 2000);
-        }
-        else {
-            waitTime = Math.max(configuredTimeout, 500);
-        }
+        const siInjectionEnabled = this._configurationService.getValue(TerminalSettingId.ShellIntegrationEnabled) === true;
+        const waitTime = getShellIntegrationTimeout(this._configurationService, siInjectionEnabled, instance.hasRemoteAuthority, processReadyTimestamp);
         if (ToolTerminalCreator_1._lastSuccessfulShell !== ShellLaunchType.Fallback ||
             siInjectionEnabled) {
             this._logService.info(`ToolTerminalCreator#createTerminal: Waiting ${waitTime}ms for shell integration`);
@@ -98,6 +92,7 @@ let ToolTerminalCreator = class ToolTerminalCreator {
         const config = {
             icon: ThemeIcon.fromId(Codicon.chatSparkle.id),
             hideFromUser: true,
+            forcePersist: true,
             env: {
                 GIT_PAGER: 'cat',
             }
@@ -149,14 +144,12 @@ let ToolTerminalCreator = class ToolTerminalCreator {
                 }, 200));
             }
             else {
-                store.add(instance.capabilities.onDidAddCapabilityType(e => {
-                    if (e === TerminalCapability.CommandDetection) {
-                        siNoneTimer.clear();
-                        store.add(disposableTimeout(() => {
-                            this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI (via listener)`);
-                            result.complete(ShellIntegrationQuality.Basic);
-                        }, 200));
-                    }
+                store.add(instance.capabilities.onDidAddCommandDetectionCapability(e => {
+                    siNoneTimer.clear();
+                    store.add(disposableTimeout(() => {
+                        this._logService.info(`ToolTerminalCreator#_waitForShellIntegration: Timed out 200ms, using basic SI (via listener)`);
+                        result.complete(ShellIntegrationQuality.Basic);
+                    }, 200));
                 }));
             }
         }

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

@@ -0,0 +1,23 @@
+import type { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import type { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import type { ToolConfirmationAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import type { TreeSitterCommandParserLanguage } from "../../treeSitterCommandParser.js";
+export interface ICommandLineAnalyzer extends IDisposable {
+    analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
+}
+export interface ICommandLineAnalyzerOptions {
+    commandLine: string;
+    cwd: URI | undefined;
+    shell: string;
+    os: OperatingSystem;
+    treeSitterLanguage: TreeSitterCommandParserLanguage;
+    terminalToolSessionId: string;
+}
+export interface ICommandLineAnalyzerResult {
+    readonly isAutoApproveAllowed: boolean;
+    readonly disclaimers?: readonly string[];
+    readonly autoApproveInfo?: IMarkdownString;
+    readonly customActions?: ToolConfirmationAction[];
+}

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

@@ -0,0 +1,18 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import type { RunInTerminalToolTelemetry } from "../../runInTerminalToolTelemetry.js";
+import { type TreeSitterCommandParser } from "../../treeSitterCommandParser.js";
+import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from "./commandLineAnalyzer.js";
+export declare class CommandLineAutoApproveAnalyzer extends Disposable implements ICommandLineAnalyzer {
+    private readonly _treeSitterCommandParser;
+    private readonly _telemetry;
+    private readonly _log;
+    private readonly _configurationService;
+    private readonly _storageService;
+    private readonly _commandLineAutoApprover;
+    constructor(_treeSitterCommandParser: TreeSitterCommandParser, _telemetry: RunInTerminalToolTelemetry, _log: (message: string, ...args: unknown[]) => void, _configurationService: IConfigurationService, instantiationService: IInstantiationService, _storageService: IStorageService);
+    analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
+    private _createAutoApproveInfo;
+}

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

@@ -0,0 +1,227 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { asArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { createCommandUri, MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { TerminalToolConfirmationStorageKeys } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart';
+import { openTerminalSettingsLinkCommandId } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolProgressPart';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-de235d7f-e72a-5adb-9256-acf6c64eb6f2-common/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { CommandLineAutoApprover } from '../../commandLineAutoApprover.js';
+import { isPowerShell, generateAutoApproveActions, dedupeRules } from '../../runInTerminalHelpers.js';
+
+const promptInjectionWarningCommandsLower = [
+    'curl',
+    'wget',
+];
+const promptInjectionWarningCommandsLowerPwshOnly = [
+    'invoke-restmethod',
+    'invoke-webrequest',
+    'irm',
+    'iwr',
+];
+let CommandLineAutoApproveAnalyzer = class CommandLineAutoApproveAnalyzer extends Disposable {
+    constructor(_treeSitterCommandParser, _telemetry, _log, _configurationService, instantiationService, _storageService) {
+        super();
+        this._treeSitterCommandParser = _treeSitterCommandParser;
+        this._telemetry = _telemetry;
+        this._log = _log;
+        this._configurationService = _configurationService;
+        this._storageService = _storageService;
+        this._commandLineAutoApprover = this._register(instantiationService.createInstance(CommandLineAutoApprover));
+    }
+    async analyze(options) {
+        let subCommands;
+        try {
+            subCommands = await this._treeSitterCommandParser.extractSubCommands(options.treeSitterLanguage, options.commandLine);
+            this._log(`Parsed sub-commands via ${options.treeSitterLanguage} grammar`, subCommands);
+        }
+        catch (e) {
+            console.error(e);
+            this._log(`Failed to parse sub-commands via ${options.treeSitterLanguage} grammar`);
+        }
+        let isAutoApproved = false;
+        let autoApproveInfo;
+        let customActions;
+        if (!subCommands) {
+            return {
+                isAutoApproveAllowed: false,
+                disclaimers: [],
+            };
+        }
+        const subCommandResults = ( subCommands.map(
+            e => this._commandLineAutoApprover.isCommandAutoApproved(e, options.shell, options.os)
+        ));
+        const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(options.commandLine);
+        const autoApproveReasons = [
+            ...( subCommandResults.map(e => e.reason)),
+            commandLineResult.reason,
+        ];
+        let isDenied = false;
+        let autoApproveReason;
+        let autoApproveDefault;
+        const deniedSubCommandResult = subCommandResults.find(e => e.result === 'denied');
+        if (deniedSubCommandResult) {
+            this._log('Sub-command DENIED auto approval');
+            isDenied = true;
+            autoApproveDefault = deniedSubCommandResult.rule?.isDefaultRule;
+            autoApproveReason = 'subCommand';
+        }
+        else if (commandLineResult.result === 'denied') {
+            this._log('Command line DENIED auto approval');
+            isDenied = true;
+            autoApproveDefault = commandLineResult.rule?.isDefaultRule;
+            autoApproveReason = 'commandLine';
+        }
+        else {
+            if (subCommandResults.every(e => e.result === 'approved')) {
+                this._log('All sub-commands auto-approved');
+                autoApproveReason = 'subCommand';
+                isAutoApproved = true;
+                autoApproveDefault = subCommandResults.every(e => e.rule?.isDefaultRule);
+            }
+            else {
+                this._log('All sub-commands NOT auto-approved');
+                if (commandLineResult.result === 'approved') {
+                    this._log('Command line auto-approved');
+                    autoApproveReason = 'commandLine';
+                    isAutoApproved = true;
+                    autoApproveDefault = commandLineResult.rule?.isDefaultRule;
+                }
+                else {
+                    this._log('Command line NOT auto-approved');
+                }
+            }
+        }
+        for (const reason of autoApproveReasons) {
+            this._log(`- ${reason}`);
+        }
+        const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
+        const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
+        if (isAutoApproveEnabled && isAutoApproved) {
+            autoApproveInfo = this._createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult);
+        }
+        else {
+            isAutoApproved = false;
+        }
+        this._telemetry.logPrepare({
+            terminalToolSessionId: options.terminalToolSessionId,
+            subCommands,
+            autoApproveAllowed: !isAutoApproveEnabled ? 'off' : isAutoApproveWarningAccepted ? 'allowed' : 'needsOptIn',
+            autoApproveResult: isAutoApproved ? 'approved' : isDenied ? 'denied' : 'manual',
+            autoApproveReason,
+            autoApproveDefault
+        });
+        const disclaimers = [];
+        const subCommandsLowerFirstWordOnly = ( subCommands.map(command => command.split(' ')[0].toLowerCase()));
+        if (!isAutoApproved && (( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLower.includes(command))) ||
+            (isPowerShell(options.shell, options.os) && ( subCommandsLowerFirstWordOnly.some(command => promptInjectionWarningCommandsLowerPwshOnly.includes(command)))))) {
+            disclaimers.push(( localize(
+                11835,
+                'Web content may contain malicious code or attempt prompt injection attacks.'
+            )));
+        }
+        if (!isAutoApproved && isAutoApproveEnabled) {
+            customActions = generateAutoApproveActions(options.commandLine, subCommands, { subCommandResults, commandLineResult });
+        }
+        return {
+            isAutoApproveAllowed: isAutoApproved,
+            disclaimers,
+            autoApproveInfo,
+            customActions,
+        };
+    }
+    _createAutoApproveInfo(isAutoApproved, isDenied, autoApproveReason, subCommandResults, commandLineResult) {
+        const formatRuleLinks = (result) => {
+            return ( asArray(result).map(e => {
+                const settingsUri = createCommandUri(openTerminalSettingsLinkCommandId, e.rule.sourceTarget);
+                return `[\`${e.rule.sourceText}\`](${( settingsUri.toString())} "${( localize(11836, 'View rule in settings'))}")`;
+            })).join(', ');
+        };
+        const mdTrustSettings = {
+            isTrusted: {
+                enabledCommands: [openTerminalSettingsLinkCommandId]
+            }
+        };
+        const config = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
+        const isGlobalAutoApproved = config?.value ?? config.defaultValue;
+        if (isGlobalAutoApproved) {
+            const settingsUri = createCommandUri(openTerminalSettingsLinkCommandId, 'global');
+            return (new MarkdownString(`${( localize(
+                11837,
+                'Auto approved by setting {0}',
+                `[\`${ChatConfiguration.GlobalAutoApprove}\`](${( settingsUri.toString())} "${( localize(11838, 'View settings'))}")`
+            ))}`, mdTrustSettings));
+        }
+        if (isAutoApproved) {
+            switch (autoApproveReason) {
+                case 'commandLine': {
+                    if (commandLineResult.rule) {
+                        return (new MarkdownString(
+                            localize(11839, 'Auto approved by rule {0}', formatRuleLinks(commandLineResult)),
+                            mdTrustSettings
+                        ));
+                    }
+                    break;
+                }
+                case 'subCommand': {
+                    const uniqueRules = dedupeRules(subCommandResults);
+                    if (uniqueRules.length === 1) {
+                        return (new MarkdownString(
+                            localize(11839, 'Auto approved by rule {0}', formatRuleLinks(uniqueRules)),
+                            mdTrustSettings
+                        ));
+                    }
+                    else if (uniqueRules.length > 1) {
+                        return (new MarkdownString(
+                            localize(11840, 'Auto approved by rules {0}', formatRuleLinks(uniqueRules)),
+                            mdTrustSettings
+                        ));
+                    }
+                    break;
+                }
+            }
+        }
+        else if (isDenied) {
+            switch (autoApproveReason) {
+                case 'commandLine': {
+                    if (commandLineResult.rule) {
+                        return (new MarkdownString(localize(
+                            11841,
+                            'Auto approval denied by rule {0}',
+                            formatRuleLinks(commandLineResult)
+                        ), mdTrustSettings));
+                    }
+                    break;
+                }
+                case 'subCommand': {
+                    const uniqueRules = dedupeRules(subCommandResults.filter(e => e.result === 'denied'));
+                    if (uniqueRules.length === 1) {
+                        return (new MarkdownString(
+                            localize(11841, 'Auto approval denied by rule {0}', formatRuleLinks(uniqueRules))
+                        ));
+                    }
+                    else if (uniqueRules.length > 1) {
+                        return (new MarkdownString(
+                            localize(11842, 'Auto approval denied by rules {0}', formatRuleLinks(uniqueRules))
+                        ));
+                    }
+                    break;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+CommandLineAutoApproveAnalyzer = ( __decorate([
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IStorageService))
+], CommandLineAutoApproveAnalyzer));
+
+export { CommandLineAutoApproveAnalyzer };

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

@@ -0,0 +1,17 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { type TreeSitterCommandParser } from "../../treeSitterCommandParser.js";
+import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from "./commandLineAnalyzer.js";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+export declare class CommandLineFileWriteAnalyzer extends Disposable implements ICommandLineAnalyzer {
+    private readonly _treeSitterCommandParser;
+    private readonly _log;
+    private readonly _configurationService;
+    private readonly _labelService;
+    private readonly _workspaceContextService;
+    constructor(_treeSitterCommandParser: TreeSitterCommandParser, _log: (message: string, ...args: unknown[]) => void, _configurationService: IConfigurationService, _labelService: ILabelService, _workspaceContextService: IWorkspaceContextService);
+    analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
+    private _getFileWrites;
+    private _getResult;
+}