@codingame/monaco-vscode-katex-common 33.0.9 → 34.0.1

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

@@ -1,142 +0,0 @@
-
-
-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

@@ -1,52 +0,0 @@
-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

@@ -1,232 +0,0 @@
-
-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

@@ -1,65 +0,0 @@
-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>;