@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.0

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

@@ -0,0 +1,144 @@
+
+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 { isMacintosh, isCI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
+import { trackIdleOnPrompt } 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';
+
+let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
+    constructor(_instance, _commandDetection, _configurationService, _logService) {
+        super();
+        this._instance = _instance;
+        this._commandDetection = _commandDetection;
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this.type = "rich";
+        this._startMarker = this._register(( new MutableDisposable()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
+        this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
+    }
+    async execute(commandLine, token, commandId, commandLineForMetadata) {
+        const store = ( new DisposableStore());
+        this._register(store);
+        try {
+            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));
+            const idlePollInterval = this._configurationService.getValue(TerminalChatAgentToolsSettingId.IdlePollInterval) ?? 1000;
+            const onDone = Promise.race([
+                Event.toPromise(this._commandDetection.onCommandFinished, store).then(e => {
+                    this._log("onDone via end event");
+                    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"
+                    };
+                }),
+                trackIdleOnPrompt(this._instance, idlePollInterval, store, idlePollInterval).then(() => {
+                    this._log("onDone via idle prompt");
+                })
+            ]);
+            const markerRecreation = setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
+            this._log(`Executing command line \`${commandLine}\``);
+            markerRecreation.dispose();
+            const forceBracketedPasteMode = isMacintosh;
+            this._instance.runCommand(
+                commandLine,
+                true,
+                commandId,
+                forceBracketedPasteMode,
+                commandLineForMetadata
+            );
+            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 (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");
+            }
+            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) {
+        const msg = `RunInTerminalTool#Rich: ${message}`;
+        if (isCI) {
+            this._logService.info(msg);
+        } else {
+            this._logService.debug(msg);
+        }
+    }
+};
+RichExecuteStrategy = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ITerminalLogService))], RichExecuteStrategy));
+
+export { RichExecuteStrategy };

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

@@ -0,0 +1,40 @@
+import { DisposableStore, MutableDisposable, type IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+/**
+ * Sets up a recreating start marker which is resilient to prompts that clear/re-render (eg. transient
+ * or powerlevel10k style prompts). The marker is recreated at the cursor position whenever the
+ * existing marker is disposed. The caller is responsible for adding the startMarker to the store.
+ */
+export declare function setupRecreatingStartMarker(xterm: {
+    raw: {
+        registerMarker(): IXtermMarker | undefined;
+    };
+}, startMarker: MutableDisposable<IXtermMarker>, fire: (marker: IXtermMarker | undefined) => void, store: DisposableStore, log?: (message: string) => void): IDisposable;
+export declare function createAltBufferPromise(xterm: {
+    raw: {
+        buffer: {
+            active: unknown;
+            alternate: unknown;
+            onBufferChange: (callback: () => void) => IDisposable;
+        };
+    };
+}, store: DisposableStore, log?: (message: string) => void): Promise<void>;
+/**
+ * Strips the command echo and trailing prompt lines from marker-based terminal output.
+ * Without shell integration (or when `getOutput()` is unavailable), `getContentsAsText`
+ * captures the entire terminal buffer between the start and end markers, which includes:
+ * 1. The command echo line (what `sendText` wrote)
+ * 2. The actual command output
+ * 3. The next shell prompt line(s)
+ *
+ * This function removes (1) and (3) to isolate the actual output.
+ */
+export declare function stripCommandEchoAndPrompt(output: string, commandLine: string, log?: (message: string) => void): string;
+export declare function findCommandEcho(output: string, commandLine: string, allowSuffixMatch?: boolean): {
+    contentBefore: string;
+    linesAfter: string[];
+} | undefined;
+export declare function stripNewLinesAndBuildMapping(output: string): {
+    strippedOutput: string;
+    indexMapping: number[];
+};

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

@@ -0,0 +1,174 @@
+
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+function setupRecreatingStartMarker(xterm, startMarker, fire, store, log) {
+    const markerListener = ( new MutableDisposable());
+    const recreateStartMarker = () => {
+        if (store.isDisposed) {
+            return;
+        }
+        const marker = xterm.raw.registerMarker();
+        startMarker.value = marker ?? undefined;
+        fire(marker);
+        if (!marker) {
+            markerListener.clear();
+            return;
+        }
+        markerListener.value = marker.onDispose(() => {
+            log?.("Start marker was disposed, recreating");
+            recreateStartMarker();
+        });
+    };
+    recreateStartMarker();
+    store.add(toDisposable(() => {
+        markerListener.dispose();
+        startMarker.clear();
+        fire(undefined);
+    }));
+    store.add(startMarker);
+    return toDisposable(() => markerListener.dispose());
+}
+function createAltBufferPromise(xterm, store, log) {
+    const deferred = ( new DeferredPromise());
+    const complete = () => {
+        if (!deferred.isSettled) {
+            log?.("Detected alternate buffer entry");
+            deferred.complete();
+        }
+    };
+    if (xterm.raw.buffer.active === xterm.raw.buffer.alternate) {
+        complete();
+    } else {
+        store.add(xterm.raw.buffer.onBufferChange(() => {
+            if (xterm.raw.buffer.active === xterm.raw.buffer.alternate) {
+                complete();
+            }
+        }));
+    }
+    return deferred.p;
+}
+function stripCommandEchoAndPrompt(output, commandLine, log) {
+    log?.(
+        `stripCommandEchoAndPrompt input: output length=${output.length}, commandLine length=${commandLine.length}`
+    );
+    const result = _stripCommandEchoAndPromptOnce(output, commandLine, log);
+    if (result.trim().length > 0 && findCommandEcho(result, commandLine)) {
+        return _stripCommandEchoAndPromptOnce(result, commandLine, log);
+    }
+    return result;
+}
+function _stripCommandEchoAndPromptOnce(output, commandLine, log) {
+    const echoResult = findCommandEcho(output, commandLine,  true);
+    const lines = echoResult ? echoResult.linesAfter : output.split("\n");
+    const startIndex = 0;
+    const promptBefore = echoResult?.contentBefore ?? "";
+    const isUnixAt = /\w+@[\w.-]+:/.test(promptBefore);
+    const isUnixHost = !isUnixAt && /[\w.-]+:\S/.test(promptBefore);
+    const isUnix = isUnixAt || isUnixHost;
+    const isPowerShell = /^PS\s/i.test(promptBefore);
+    const isCmd = !isPowerShell && /^[A-Z]:\\/.test(promptBefore);
+    const isStarship = /\u276f/.test(promptBefore);
+    const isPython = />>>/.test(promptBefore);
+    const knownPrompt = isUnix || isPowerShell || isCmd || isStarship || isPython;
+    let endIndex = lines.length;
+    let trailingStrippedCount = 0;
+    const maxTrailingPromptLines = 2;
+    while (endIndex > startIndex) {
+        const line = lines[endIndex - 1].trimEnd();
+        if (line.length === 0) {
+            endIndex--;
+            continue;
+        }
+        if (trailingStrippedCount >= maxTrailingPromptLines) {
+            break;
+        }
+        const isCompletePrompt =
+        ((!knownPrompt || isUnixAt) && /^\s*\w+@[\w.-]+:.*[#$]\s*$/.test(line)) || ((!knownPrompt || isUnixHost) && /^\s*[\w.-]+:\S.*\s\w+[#$]\s*$/.test(line)) || ((!knownPrompt || isPowerShell) && /^PS\s+[A-Z]:\\.*>\s*$/.test(line)) || ((!knownPrompt || isCmd) && /^[A-Z]:\\.*>\s*$/.test(line)) || ((!knownPrompt || isStarship) && /\u276f\s*$/.test(line)) || ((!knownPrompt || isPython) && /^>>>\s*$/.test(line));
+        const isPromptFragment =
+        ((!knownPrompt || isUnix) && /^\s*[\w/.-]+[#$]\s*$/.test(line)) || ((!knownPrompt || isUnix) && /^\[\s*[\w.-]+(@[\w.-]+)?:[~\/]/.test(line)) || ((!knownPrompt || isUnix) && trailingStrippedCount > 0 && /^\s*[\w][-\w.]*(@[\w.-]+)?:\S/.test(line)) || ((!knownPrompt || isUnix) && /\]\s*[#$]\s*$/.test(line));
+        if (isCompletePrompt) {
+            endIndex--;
+            trailingStrippedCount++;
+            break;
+        } else if (isPromptFragment) {
+            endIndex--;
+            trailingStrippedCount++;
+        } else {
+            break;
+        }
+    }
+    const result = lines.slice(startIndex, endIndex).join("\n");
+    log?.(
+        `stripCommandEchoAndPrompt result: length=${result.length} (startIndex=${startIndex}, endIndex=${endIndex}, totalLines=${lines.length})`
+    );
+    return result;
+}
+function findCommandEcho(output, commandLine, allowSuffixMatch) {
+    const trimmedCommand = commandLine.trim();
+    if (trimmedCommand.length === 0) {
+        return undefined;
+    }
+    const {
+        strippedOutput,
+        indexMapping
+    } = stripNewLinesAndBuildMapping(output);
+    const matchIndex = strippedOutput.indexOf(trimmedCommand);
+    let matchEndInStripped;
+    let contentBefore;
+    if (matchIndex !== -1) {
+        contentBefore = strippedOutput.substring(0, matchIndex).trim();
+        matchEndInStripped = matchIndex + trimmedCommand.length - 1;
+    } else if (allowSuffixMatch) {
+        let suffixLen = 0;
+        for (let len = trimmedCommand.length - 1; len >= 1; len--) {
+            const suffix = trimmedCommand.substring(trimmedCommand.length - len);
+            if (strippedOutput.startsWith(suffix)) {
+                const charBefore = trimmedCommand[trimmedCommand.length - len - 1];
+                if (charBefore !== undefined && charBefore !== " " && charBefore !== "\t") {
+                    suffixLen = len;
+                }
+                break;
+            }
+        }
+        if (suffixLen === 0) {
+            return undefined;
+        }
+        contentBefore = "";
+        matchEndInStripped = suffixLen - 1;
+    } else {
+        return undefined;
+    }
+    const originalEnd = indexMapping[matchEndInStripped];
+    const lines = output.split("\n");
+    let echoEndLine = 0;
+    let offset = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const lineEnd = offset + lines[i].length;
+        if (offset <= originalEnd && originalEnd <= lineEnd) {
+            echoEndLine = i + 1;
+            break;
+        }
+        offset = lineEnd + 1;
+    }
+    return {
+        contentBefore,
+        linesAfter: lines.slice(echoEndLine)
+    };
+}
+function stripNewLinesAndBuildMapping(output) {
+    const indexMapping = [];
+    const strippedChars = [];
+    for (let i = 0; i < output.length; i++) {
+        if (output[i] !== "\n") {
+            strippedChars.push(output[i]);
+            indexMapping.push(i);
+        }
+    }
+    return {
+        strippedOutput: strippedChars.join(""),
+        indexMapping
+    };
+}
+
+export { createAltBufferPromise, findCommandEcho, setupRecreatingStartMarker, stripCommandEchoAndPrompt, stripNewLinesAndBuildMapping };

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

@@ -0,0 +1,7 @@
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+export interface IGetOutputOptions {
+    /** When set, only return the last N non-empty lines from the bottom of the buffer. */
+    lastNLines?: number;
+}
+export declare function getOutput(instance: ITerminalInstance, startMarker?: IXtermMarker, options?: IGetOutputOptions): string;

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

@@ -0,0 +1,43 @@
+
+import { truncateOutputKeepingTail } from './runInTerminalHelpers.js';
+
+const MAX_OUTPUT_LENGTH = 16000;
+function getOutput(instance, startMarker, options) {
+    if (!instance.xterm || !instance.xterm.raw) {
+        return '';
+    }
+    const buffer = instance.xterm.raw.buffer.active;
+    let startLine = Math.max(startMarker?.line ?? 0, 0);
+    while (startLine > 0 && buffer.getLine(startLine)?.isWrapped) {
+        startLine--;
+    }
+    const endLine = buffer.length;
+    const lines = [];
+    let currentLine = '';
+    for (let y = startLine; y < endLine; y++) {
+        const line = buffer.getLine(y);
+        if (!line) {
+            continue;
+        }
+        const isWrapped = !!buffer.getLine(y + 1)?.isWrapped;
+        currentLine += line.translateToString(!isWrapped);
+        if (!isWrapped) {
+            lines.push(currentLine);
+            currentLine = '';
+        }
+    }
+    if (currentLine) {
+        lines.push(currentLine);
+    }
+    if (options?.lastNLines !== undefined) {
+        const nonEmpty = lines.filter(l => l.trim().length > 0);
+        return nonEmpty.slice(-options.lastNLines).join('\n');
+    }
+    let output = lines.join('\n');
+    if (output.length > MAX_OUTPUT_LENGTH) {
+        output = truncateOutputKeepingTail(output, MAX_OUTPUT_LENGTH);
+    }
+    return output;
+}
+
+export { getOutput };

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

@@ -0,0 +1,42 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ToolConfirmationAction } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import type { ICommandApprovalResultWithReason } from "./tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js";
+export declare function isPowerShell(envShell: string, os: OperatingSystem): boolean;
+export declare function isWindowsPowerShell(envShell: string): boolean;
+export declare function isZsh(envShell: string, os: OperatingSystem): boolean;
+export declare function isBash(envShell: string, os: OperatingSystem): boolean;
+export declare function isFish(envShell: string, os: OperatingSystem): boolean;
+export declare const TRUNCATION_MESSAGE = "\n\n[... PREVIOUS OUTPUT TRUNCATED ...]\n\n";
+export declare function truncateOutputKeepingTail(output: string, maxLength: number): string;
+export declare function sanitizeTerminalOutput(output: string): string;
+/**
+ * Normalizes command text for UI display by removing unnecessary quote and forward slash
+ * escaping artifacts (for example: \" \' \/) commonly produced in streamed tool-call JSON.
+ */
+export declare function normalizeTerminalCommandForDisplay(commandLine: string): string;
+/**
+ * Builds a single-line display string for a terminal command, suitable for UI messages.
+ * Normalizes escape artifacts, collapses newlines to spaces, and truncates to 80 characters.
+ */
+export declare function buildCommandDisplayText(command: string): string;
+/**
+ * Normalizes a terminal command for execution by collapsing newlines to spaces.
+ * This prevents multi-line input from being sent as multiple commands via sendText.
+ */
+export declare function normalizeCommandForExecution(command: string): string;
+export declare function generateAutoApproveActions(commandLine: string, subCommands: string[], autoApproveResult: {
+    subCommandResults: ICommandApprovalResultWithReason[];
+    commandLineResult: ICommandApprovalResultWithReason;
+}): ToolConfirmationAction[];
+export declare function dedupeRules(rules: ICommandApprovalResultWithReason[]): ICommandApprovalResultWithReason[];
+export interface IExtractedCdPrefix {
+    /** The directory path that was extracted from the cd command */
+    directory: string;
+    /** The command to run after the cd */
+    command: string;
+}
+/**
+ * Extracts a cd prefix from a command line, returning the directory and remaining command.
+ * Does not check if the directory matches the current cwd - just extracts the pattern.
+ */
+export declare function extractCdPrefix(commandLine: string, shell: string, os: OperatingSystem): IExtractedCdPrefix | undefined;