@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

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

@@ -0,0 +1,94 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { trackIdleOnPrompt } from './executeStrategy.js';
+
+let RichExecuteStrategy = class RichExecuteStrategy {
+    constructor(_instance, _commandDetection, _logService) {
+        this._instance = _instance;
+        this._commandDetection = _commandDetection;
+        this._logService = _logService;
+        this.type = 'rich';
+    }
+    async execute(commandLine, token) {
+        const store = ( new DisposableStore());
+        try {
+            this._log('Waiting for xterm');
+            const xterm = await this._instance.xtermReadyPromise;
+            if (!xterm) {
+                throw ( new Error('Xterm is not available'));
+            }
+            const onDone = Promise.race([
+                Event.toPromise(this._commandDetection.onCommandFinished, store).then(e => {
+                    this._log('onDone via end event');
+                    return e;
+                }),
+                Event.toPromise(token.onCancellationRequested, store).then(() => {
+                    this._log('onDone via cancellation');
+                }),
+                trackIdleOnPrompt(this._instance, 1000, store).then(() => {
+                    this._log('onDone via idle prompt');
+                }),
+            ]);
+            let startMarker = store.add(xterm.raw.registerMarker());
+            store.add(startMarker.onDispose(() => {
+                this._log(`Start marker was disposed, recreating`);
+                startMarker = xterm.raw.registerMarker();
+            }));
+            this._log(`Executing command line \`${commandLine}\``);
+            this._instance.runCommand(commandLine, true);
+            this._log('Waiting for done event');
+            const finishedCommand = await onDone;
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const endMarker = store.add(xterm.raw.registerMarker());
+            let output;
+            const additionalInformationLines = [];
+            if (finishedCommand) {
+                const commandOutput = finishedCommand?.getOutput();
+                if (commandOutput !== undefined) {
+                    this._log('Fetched output via finished command');
+                    output = commandOutput;
+                }
+            }
+            if (output === undefined) {
+                try {
+                    output = xterm.getContentsAsText(startMarker, endMarker);
+                    this._log('Fetched output via markers');
+                }
+                catch {
+                    this._log('Failed to fetch output via markers');
+                    additionalInformationLines.push('Failed to retrieve command output');
+                }
+            }
+            if (output !== undefined && output.trim().length === 0) {
+                additionalInformationLines.push('Command produced no output');
+            }
+            const exitCode = finishedCommand?.exitCode;
+            if (isNumber(exitCode) && exitCode > 0) {
+                additionalInformationLines.push(`Command exited with code ${exitCode}`);
+            }
+            return {
+                output,
+                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join('\n') : undefined,
+                exitCode,
+            };
+        }
+        finally {
+            store.dispose();
+        }
+    }
+    _log(message) {
+        this._logService.debug(`RunInTerminalTool#Rich: ${message}`);
+    }
+};
+RichExecuteStrategy = ( __decorate([
+    ( __param(2, ITerminalLogService))
+], RichExecuteStrategy));
+
+export { RichExecuteStrategy };

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

@@ -0,0 +1,11 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type CountTokensCallback, type IPreparedToolInvocation, type IToolData, type IToolImpl, type IToolInvocation, type IToolInvocationPreparationContext, type IToolResult, type ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+export declare const GetTerminalOutputToolData: IToolData;
+export interface IGetTerminalOutputInputParams {
+    id: string;
+}
+export declare class GetTerminalOutputTool extends Disposable implements IToolImpl {
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+}

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

@@ -0,0 +1,44 @@
+
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { RunInTerminalTool } from './runInTerminalTool.js';
+
+const GetTerminalOutputToolData = {
+    id: 'get_terminal_output',
+    toolReferenceName: 'getTerminalOutput',
+    displayName: ( localize(11258, 'Get Terminal Output')),
+    modelDescription: 'Get the output of a terminal command previously started with run_in_terminal',
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: {
+                type: 'string',
+                description: 'The ID of the terminal to check.'
+            },
+        },
+        required: [
+            'id',
+        ]
+    }
+};
+class GetTerminalOutputTool extends Disposable {
+    async prepareToolInvocation(context, token) {
+        return {
+            invocationMessage: ( localize(11259, "Checking background terminal output")),
+            pastTenseMessage: ( localize(11260, "Checked background terminal output")),
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const args = invocation.parameters;
+        return {
+            content: [{
+                    kind: 'text',
+                    value: `Output of terminal ${args.id}:\n${RunInTerminalTool.getBackgroundOutput(args.id)}`
+                }]
+        };
+    }
+}
+
+export { GetTerminalOutputTool, GetTerminalOutputToolData };

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

@@ -0,0 +1,3 @@
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+export declare function getOutput(instance: ITerminalInstance, startMarker?: IXtermMarker): string;

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

@@ -0,0 +1,18 @@
+
+
+function getOutput(instance, startMarker) {
+    if (!instance.xterm || !instance.xterm.raw) {
+        return '';
+    }
+    const lines = [];
+    for (let y = Math.min(0, 0); y < instance.xterm.raw.buffer.active.length; y++) {
+        const line = instance.xterm.raw.buffer.active.getLine(y);
+        if (!line) {
+            continue;
+        }
+        lines.push(line.translateToString(true));
+    }
+    return lines.join('\n');
+}
+
+export { getOutput };

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

@@ -0,0 +1,3 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+export declare function isPowerShell(envShell: string, os: OperatingSystem): boolean;
+export declare function sanitizeTerminalOutput(output: string): string;

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

@@ -0,0 +1,13 @@
+
+import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+
+function isPowerShell(envShell, os) {
+    if (os === OperatingSystem.Windows) {
+        return /^(?:powershell|pwsh)(?:-preview)?$/i.test(win32.basename(envShell).replace(/\.exe$/i, ''));
+    }
+    return /^(?:powershell|pwsh)(?:-preview)?$/.test(posix.basename(envShell));
+}
+
+export { isPowerShell };

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

@@ -0,0 +1,55 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+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 { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IRemoteAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } 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 { type ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalProfileResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
+import { CommandLineAutoApprover } from "./commandLineAutoApprover.js";
+import { type IToolTerminal } from "./toolTerminalCreator.js";
+export declare const RunInTerminalToolData: IToolData;
+export interface IRunInTerminalInputParams {
+    command: string;
+    explanation: string;
+    isBackground: boolean;
+}
+export declare class RunInTerminalTool extends Disposable implements IToolImpl {
+    private readonly _instantiationService;
+    private readonly _languageModelToolsService;
+    private readonly _storageService;
+    private readonly _telemetryService;
+    private readonly _logService;
+    private readonly _terminalProfileResolverService;
+    private readonly _terminalService;
+    private readonly _remoteAgentService;
+    private readonly _chatService;
+    private readonly _workspaceContextService;
+    private readonly _languageModelsService;
+    protected readonly _commandLineAutoApprover: CommandLineAutoApprover;
+    protected readonly _sessionTerminalAssociations: Map<string, IToolTerminal>;
+    protected readonly _osBackend: Promise<OperatingSystem>;
+    private _alternativeRecommendation?;
+    private static readonly _backgroundExecutions;
+    static getBackgroundOutput(id: string): string;
+    constructor(_instantiationService: IInstantiationService, _languageModelToolsService: ILanguageModelToolsService, _storageService: IStorageService, _telemetryService: ITelemetryService, _logService: ITerminalLogService, _terminalProfileResolverService: ITerminalProfileResolverService, _terminalService: ITerminalService, _remoteAgentService: IRemoteAgentService, _chatService: IChatService, _workspaceContextService: IWorkspaceContextService, _languageModelsService: ILanguageModelsService);
+    prepareToolInvocation(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    private _initBackgroundTerminal;
+    private _initForegroundTerminal;
+    protected _rewriteCommandIfNeeded(args: IRunInTerminalInputParams, instance: Pick<ITerminalInstance, "getCwdResource"> | undefined, shell: string): Promise<string>;
+    private _restoreTerminalAssociations;
+    private _setupProcessIdAssociation;
+    private _associateProcessIdWithSession;
+    private _removeProcessIdAssociation;
+    private _cleanupSessionTerminals;
+    private _sendTelemetry;
+}