@codingame/monaco-vscode-chat-service-override 33.0.9 → 34.0.1

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

@@ -0,0 +1,142 @@
+
+
+class SedFileWriteParser {
+    constructor() {
+        this.commandName = 'sed';
+    }
+    canHandle(commandText) {
+        if (!commandText.match(/^sed\s+/)) {
+            return false;
+        }
+        const inPlaceRegex = /(?:^|\s)(-[a-zA-Z]*[iI][a-zA-Z]*\S*|--in-place(?:=\S*)?|(-i|-I)\s*'[^']*'|(-i|-I)\s*"[^"]*")(?:\s|$)/;
+        return inPlaceRegex.test(commandText);
+    }
+    extractFileWrites(commandText) {
+        const tokens = this._tokenizeCommand(commandText);
+        return this._extractFileTargets(tokens);
+    }
+    _tokenizeCommand(commandText) {
+        const tokens = [];
+        let current = '';
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let escaped = false;
+        for (let i = 0; i < commandText.length; i++) {
+            const char = commandText[i];
+            if (escaped) {
+                current += char;
+                escaped = false;
+                continue;
+            }
+            if (char === '\\' && !inSingleQuote) {
+                escaped = true;
+                current += char;
+                continue;
+            }
+            if (char === '\'' && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+                current += char;
+                continue;
+            }
+            if (char === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+                current += char;
+                continue;
+            }
+            if (/\s/.test(char) && !inSingleQuote && !inDoubleQuote) {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+                continue;
+            }
+            current += char;
+        }
+        if (current) {
+            tokens.push(current);
+        }
+        return tokens;
+    }
+    _extractFileTargets(tokens) {
+        if (tokens.length === 0 || tokens[0] !== 'sed') {
+            return [];
+        }
+        const files = [];
+        let i = 1;
+        let foundScript = false;
+        while (i < tokens.length) {
+            const token = tokens[i];
+            if (token.startsWith('--')) {
+                if (token === '--in-place' || token.startsWith('--in-place=')) {
+                    i++;
+                    continue;
+                }
+                if (token === '--expression' || token === '--file') {
+                    i += 2;
+                    foundScript = true;
+                    continue;
+                }
+                if (token.startsWith('--expression=') || token.startsWith('--file=')) {
+                    i++;
+                    foundScript = true;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            if (token.startsWith('-') && token.length > 1 && token[1] !== '-') {
+                const flags = token.slice(1);
+                const iIndex = flags.indexOf('i');
+                const IIndex = flags.indexOf('I');
+                const inPlaceIndex = iIndex >= 0 ? iIndex : IIndex;
+                if (inPlaceIndex >= 0 && inPlaceIndex < flags.length - 1) {
+                    i++;
+                    continue;
+                }
+                if ((flags.endsWith('i') || flags.endsWith('I')) && i + 1 < tokens.length) {
+                    const nextToken = tokens[i + 1];
+                    if (nextToken === '\'\'' || nextToken === '""') {
+                        i += 2;
+                        continue;
+                    }
+                    if ((nextToken.startsWith('\'') && nextToken.endsWith('\'')) || (nextToken.startsWith('"') && nextToken.endsWith('"'))) {
+                        const unquoted = nextToken.slice(1, -1);
+                        if (unquoted.startsWith('.') && unquoted.length <= 10 && !unquoted.includes('/')) {
+                            i += 2;
+                            continue;
+                        }
+                    }
+                }
+                if (flags.includes('e') || flags.includes('f')) {
+                    const eIndex = flags.indexOf('e');
+                    const fIndex = flags.indexOf('f');
+                    const optIndex = eIndex >= 0 ? eIndex : fIndex;
+                    if (optIndex < flags.length - 1) {
+                        foundScript = true;
+                        i++;
+                        continue;
+                    }
+                    foundScript = true;
+                    i += 2;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            if (!foundScript) {
+                foundScript = true;
+                i++;
+                continue;
+            }
+            let file = token;
+            if ((file.startsWith('\'') && file.endsWith('\'')) || (file.startsWith('"') && file.endsWith('"'))) {
+                file = file.slice(1, -1);
+            }
+            files.push(file);
+            i++;
+        }
+        return files;
+    }
+}
+
+export { SedFileWriteParser };

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

@@ -0,0 +1,52 @@
+import type { 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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import type { ICommandDetectionCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+import { type ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+/**
+ * This strategy is used when shell integration is enabled, but rich command detection was not
+ * declared by the shell script. This is the large spectrum between rich command detection and no
+ * shell integration, here are some problems that are expected:
+ *
+ * - `133;C` command executed may not happen.
+ * - `633;E` comamnd line reporting will likely not happen, so the command line contained in the
+ *   execution start and end events will be of low confidence and chances are it will be wrong.
+ * - Execution tracking may be incorrect, particularly when `executeCommand` calls are overlapped,
+ *   such as Python activating the environment at the same time as Copilot executing a command. So
+ *   the end event for the execution may actually correspond to a different command.
+ *
+ * This strategy focuses on trying to get the most accurate output given these limitations and
+ * unknowns. Basically we cannot fully trust the extension APIs in this case, so polling of the data
+ * stream is used to detect idling, and we listen to the terminal's data stream instead of the
+ * execution's data stream.
+ *
+ * This is best effort with the goal being the output is accurate, though it may contain some
+ * content above and below the command output, such as prompts or even possibly other command
+ * output. We lean on the LLM to be able to differentiate the actual output from prompts and bad
+ * output when it's not ideal.
+ */
+export declare class BasicExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
+    private readonly _instance;
+    private readonly _hasReceivedUserInput;
+    private readonly _commandDetection;
+    private readonly _configurationService;
+    private readonly _logService;
+    readonly type = "basic";
+    private readonly _startMarker;
+    private readonly _onDidCreateStartMarker;
+    onDidCreateStartMarker: Event<IXtermMarker | undefined>;
+    /**
+     * Tracks per-execute() DisposableStores so they can be cleaned up if the
+     * strategy is disposed mid-flight, AND removed from this collection on
+     * successful completion to avoid accumulating stale references when
+     * execute() is invoked many times on the same strategy instance.
+     */
+    private readonly _executionStores;
+    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _commandDetection: ICommandDetectionCapability, _configurationService: IConfigurationService, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken, commandId?: string, _commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}

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

@@ -0,0 +1,232 @@
+
+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 { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isNumber } 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 { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { trackIdleOnPrompt, waitForIdle } from './executeStrategy.js';
+import { createAltBufferPromise, setupRecreatingStartMarker, stripCommandEchoAndPrompt } from './strategyHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { isMultilineCommand } from '../runInTerminalHelpers.js';
+
+function isTerminalLaunchError(value) {
+    return typeof value === "object" && value !== null && "message" in value;
+}
+function formatExitCodeOrError(exitCodeOrError) {
+    if (isTerminalLaunchError(exitCodeOrError)) {
+        return `launch error: ${exitCodeOrError.message}${exitCodeOrError.code !== undefined ? `, code=${exitCodeOrError.code}` : ""}`;
+    }
+    return `code=${exitCodeOrError}`;
+}
+function extractExitCode(exitCodeOrError) {
+    if (isNumber(exitCodeOrError)) {
+        return exitCodeOrError;
+    }
+    if (isTerminalLaunchError(exitCodeOrError)) {
+        return exitCodeOrError.code;
+    }
+    return undefined;
+}
+let BasicExecuteStrategy = class BasicExecuteStrategy extends Disposable {
+    constructor(
+        _instance,
+        _hasReceivedUserInput,
+        _commandDetection,
+        _configurationService,
+        _logService
+    ) {
+        super();
+        this._instance = _instance;
+        this._hasReceivedUserInput = _hasReceivedUserInput;
+        this._commandDetection = _commandDetection;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this.type = "basic";
+        this._startMarker = this._register(( new MutableDisposable()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
+        this._executionStores = this._register(( new DisposableStore()));
+    }
+    async execute(commandLine, token, commandId, _commandLineForMetadata) {
+        const store = ( new DisposableStore());
+        this._executionStores.add(store);
+        try {
+            if (this._instance.isDisposed) {
+                this._log("Terminal already disposed at strategy entry");
+                throw ( new Error("The terminal was closed"));
+            }
+            if (this._instance.exitCode !== undefined) {
+                this._log(
+                    `Terminal pty already exited at strategy entry (code=${this._instance.exitCode})`
+                );
+                return {
+                    output: undefined,
+                    exitCode: this._instance.exitCode,
+                    additionalInformation: `Command exited with code ${this._instance.exitCode}`
+                };
+            }
+            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
+            const staleMarker = this._commandDetection.executingCommandObject?.marker;
+            const onCommandFinishedFiltered = staleMarker ? Event.filter(
+                this._commandDetection.onCommandFinished,
+                e => e.marker !== staleMarker,
+                store
+            ) : this._commandDetection.onCommandFinished;
+            const idlePromptPromise = trackIdleOnPrompt(
+                this._instance,
+                idlePollInterval,
+                store,
+                idlePollInterval,
+                this._logService
+            );
+            const onDone = Promise.race([Event.toPromise(onCommandFinishedFiltered, store).then(e => {
+                this._log("onDone 1 of 2 via end event, waiting for short idle prompt");
+                return idlePromptPromise.then(() => {
+                    this._log("onDone 2 of 2 via short idle prompt");
+                    return {
+                        "type": "success",
+                        command: e
+                    };
+                });
+            }), Event.toPromise(token.onCancellationRequested, store).then(() => {
+                this._log("onDone via cancellation");
+            }), Event.toPromise(this._instance.onDisposed, store).then(() => {
+                this._log("onDone via terminal disposal");
+                return {
+                    type: "disposal"
+                };
+            }), Event.toPromise(this._instance.onExit, store).then(exitCodeOrError => {
+                this._log(`onDone via process exit (${formatExitCodeOrError(exitCodeOrError)})`);
+                return {
+                    type: "processExit",
+                    exitCodeOrError
+                };
+            }),
+            trackIdleOnPrompt(
+                this._instance,
+                idlePollInterval * 3,
+                store,
+                idlePollInterval,
+                this._logService
+            ).then(() => {
+                this._log("onDone long idle prompt");
+            })]);
+            this._log("Waiting for xterm");
+            const xterm = await this._instance.xtermReadyPromise;
+            if (!xterm) {
+                throw ( new Error("Xterm is not available"));
+            }
+            const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
+            this._log("Waiting for idle");
+            await waitForIdle(this._instance.onData, idlePollInterval);
+            const markerRecreation = setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
+            if (this._hasReceivedUserInput()) {
+                if (this._commandDetection.executingCommandObject !== undefined) {
+                    this._log(
+                        "Previous command still executing with pending input, sending SIGINT before retrying"
+                    );
+                    await this._instance.sendText("\u0003", false);
+                    await waitForIdle(this._instance.onData, 100);
+                } else {
+                    this._log("Prompt is idle; clearing pending input with Ctrl+U instead of SIGINT");
+                    await this._instance.sendText("\u0015", false);
+                    await waitForIdle(this._instance.onData, 100);
+                }
+            }
+            if (commandId) {
+                this._log(
+                    `In basic execute strategy: skipping pre-bound command id ${commandId} because basic shell integration executes via sendText`
+                );
+            }
+            this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
+            const forceBracketedPasteMode = isMacintosh || isMultilineCommand(commandLine);
+            this._instance.sendText(commandLine, true, forceBracketedPasteMode);
+            this._log("Waiting for done event");
+            const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({
+                type: "alternateBuffer"
+            }))]);
+            if (onDoneResult && onDoneResult.type === "disposal") {
+                throw ( new Error("The terminal was closed"));
+            }
+            if (onDoneResult && onDoneResult.type === "alternateBuffer") {
+                this._log("Detected alternate buffer entry, skipping output capture");
+                return {
+                    output: undefined,
+                    exitCode: undefined,
+                    error: "alternateBuffer",
+                    didEnterAltBuffer: true
+                };
+            }
+            const finishedCommand = onDoneResult && onDoneResult.type === "success" ? onDoneResult.command : undefined;
+            if (finishedCommand) {
+                this._log(
+                    `Finished command id=${finishedCommand.id ?? "none"} for requested=${commandId ?? "none"}`
+                );
+            } else if (commandId) {
+                this._log(`No finished command surfaced for requested=${commandId}`);
+            }
+            if (!(onDoneResult && onDoneResult.type === "processExit")) {
+                this._log("Waiting for idle");
+                await waitForIdle(this._instance.onData, idlePollInterval);
+            }
+            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 = stripCommandEchoAndPrompt(commandOutput, commandLine, this._log.bind(this));
+                }
+            }
+            if (output === undefined) {
+                try {
+                    output = xterm.getContentsAsText(this._startMarker.value, endMarker);
+                    this._log("Fetched output via markers");
+                    if (output !== undefined) {
+                        output = stripCommandEchoAndPrompt(output, commandLine, this._log.bind(this));
+                    }
+                } 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");
+            }
+            let exitCode = finishedCommand?.exitCode;
+            if (exitCode === undefined && onDoneResult && onDoneResult.type === "processExit") {
+                exitCode = extractExitCode(onDoneResult.exitCodeOrError);
+            }
+            if (isNumber(exitCode) && exitCode > 0) {
+                additionalInformationLines.push(`Command exited with code ${exitCode}`);
+            }
+            return {
+                output,
+                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join("\n") : undefined,
+                exitCode
+            };
+        } finally {
+            this._executionStores.delete(store);
+        }
+    }
+    _log(message) {
+        this._logService.debug(`RunInTerminalTool#Basic: ${message}`);
+    }
+};
+BasicExecuteStrategy = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, ITerminalLogService))], BasicExecuteStrategy));
+
+export { BasicExecuteStrategy };

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

@@ -0,0 +1,65 @@
+import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import type { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { DisposableStore, type IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+export interface ITerminalExecuteStrategy extends IDisposable {
+    readonly type: "rich" | "basic" | "none";
+    /**
+     * Executes a command line and gets a result designed to be passed directly to an LLM. The
+     * result will include information about the exit code.
+     * @param commandLine The command line to execute
+     * @param token Cancellation token
+     * @param commandId Optional predefined command ID to link the command
+     * @param commandLineForMetadata Optional command line to report in terminal execution metadata.
+     * This can differ from the command line that is sent to the shell, for example when the command
+     * is wrapped for sandbox execution.
+     */
+    execute(commandLine: string, token: CancellationToken, commandId?: string, commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
+    readonly onDidCreateStartMarker: Event<IXtermMarker | undefined>;
+}
+export interface ITerminalExecuteStrategyResult {
+    output: string | undefined;
+    additionalInformation?: string;
+    exitCode?: number;
+    error?: string;
+    didEnterAltBuffer?: boolean;
+}
+export declare function waitForIdle(onData: Event<unknown>, idleDurationMs: number): Promise<void>;
+export interface IPromptDetectionResult {
+    /**
+     * Whether a prompt was detected.
+     */
+    detected: boolean;
+    /**
+     * The reason for logging.
+     */
+    reason?: string;
+}
+/**
+ * Detects if the given text content appears to end with a common prompt pattern.
+ */
+export declare function detectsCommonPromptPattern(cursorLine: string): IPromptDetectionResult;
+/**
+ * Enhanced version of {@link waitForIdle} that uses prompt detection heuristics. After the terminal
+ * idles for the specified period, checks if the terminal's cursor line looks like a common prompt.
+ * If not, extends the timeout to give the command more time to complete.
+ */
+export declare function waitForIdleWithPromptHeuristics(onData: Event<unknown>, instance: ITerminalInstance, idlePollIntervalMs: number, extendedTimeoutMs: number): Promise<IPromptDetectionResult>;
+/**
+ * Tracks the terminal for being idle on a prompt input. This must be called before `executeCommand`
+ * is called.
+ */
+export interface ITrackIdleOnPromptOptions {
+    /**
+     * When true, disables all fallback schedulers: the initial prompt fallback,
+     * the data-idle executing fallback, and the hard-cap safety net. Use this
+     * for sync (foreground) commands that should block until the command truly
+     * finishes rather than being abandoned after an idle period. In sync mode
+     * the overall chat-request timeout or user-specified timeout is the safety
+     * net instead.
+     */
+    disableFallbacks?: boolean;
+}
+export declare function trackIdleOnPrompt(instance: ITerminalInstance, idleDurationMs: number, store: DisposableStore, promptFallbackMs?: number, logService?: ITerminalLogService, options?: ITrackIdleOnPromptOptions): Promise<void>;