@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -1,137 +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 { 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) {
-        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 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);
-            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

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

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

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

@@ -1,39 +0,0 @@
-
-import { truncateOutputKeepingTail } from './runInTerminalHelpers.js';
-
-const MAX_OUTPUT_LENGTH = 16000;
-function getOutput(instance, startMarker) {
-    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);
-    }
-    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

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

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

@@ -1,249 +0,0 @@
-
-import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
-import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-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 { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { isAutoApproveRule } from './tools/commandLineAnalyzer/commandLineAnalyzer.js';
-
-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));
-}
-function isWindowsPowerShell(envShell) {
-    return envShell.endsWith("System32\\WindowsPowerShell\\v1.0\\powershell.exe");
-}
-function isZsh(envShell, os) {
-    if (os === OperatingSystem.Windows) {
-        return /^zsh(?:\.exe)?$/i.test(win32.basename(envShell));
-    }
-    return /^zsh$/.test(posix.basename(envShell));
-}
-function isBash(envShell, os) {
-    if (os === OperatingSystem.Windows) {
-        return /^bash(?:\.exe)?$/i.test(win32.basename(envShell));
-    }
-    return /^bash$/.test(posix.basename(envShell));
-}
-function isFish(envShell, os) {
-    if (os === OperatingSystem.Windows) {
-        return /^fish(?:\.exe)?$/i.test(win32.basename(envShell));
-    }
-    return /^fish$/.test(posix.basename(envShell));
-}
-const TRUNCATION_MESSAGE = "\n\n[... PREVIOUS OUTPUT TRUNCATED ...]\n\n";
-function truncateOutputKeepingTail(output, maxLength) {
-    if (output.length <= maxLength) {
-        return output;
-    }
-    const truncationMessageLength = TRUNCATION_MESSAGE.length;
-    if (truncationMessageLength >= maxLength) {
-        return TRUNCATION_MESSAGE.slice(TRUNCATION_MESSAGE.length - maxLength);
-    }
-    const availableLength = maxLength - truncationMessageLength;
-    const endPortion = output.slice(-availableLength);
-    return TRUNCATION_MESSAGE + endPortion;
-}
-function normalizeTerminalCommandForDisplay(commandLine) {
-    return commandLine.replace(/\\(["'\/])/g, "$1");
-}
-function generateAutoApproveActions(commandLine, subCommands, autoApproveResult) {
-    const actions = [];
-    const canCreateAutoApproval = (autoApproveResult.subCommandResults.every(e => e.result !== "denied") && autoApproveResult.commandLineResult.result !== "denied");
-    if (canCreateAutoApproval) {
-        const unapprovedSubCommands = subCommands.filter((_, index) => {
-            return autoApproveResult.subCommandResults[index].result !== "approved";
-        });
-        const neverAutoApproveCommands = ( new Set([
-        "bash", "sh", "zsh", "fish", "ksh", "csh", "tcsh", "dash", "pwsh", "powershell", "powershell.exe", "cmd", "cmd.exe",
-        "python", "python3", "node", "ruby", "perl", "php", "lua",
-        "eval", "exec", "source", "sudo", "su", "doas",
-        "curl", "wget", "invoke-restmethod", "invoke-webrequest", "irm", "iwr"]));
-        const commandsWithSubcommands = ( new Set([
-            "git",
-            "npm",
-            "npx",
-            "yarn",
-            "docker",
-            "kubectl",
-            "cargo",
-            "dotnet",
-            "mvn",
-            "gradle"
-        ]));
-        const commandsWithSubSubCommands = ( new Set(["npm run", "yarn run"]));
-        const findNextNonFlagArg = (parts, startIndex) => {
-            for (let i = startIndex; i < parts.length; i++) {
-                if (!parts[i].startsWith("-")) {
-                    return i;
-                }
-            }
-            return undefined;
-        };
-        const subCommandsToSuggest = Array.from(( new Set(coalesce(( unapprovedSubCommands.map(command => {
-            const parts = command.trim().split(/\s+/);
-            const baseCommand = parts[0].toLowerCase();
-            if (( neverAutoApproveCommands.has(baseCommand))) {
-                return undefined;
-            }
-            if (( commandsWithSubcommands.has(baseCommand))) {
-                const subCommandIndex = findNextNonFlagArg(parts, 1);
-                if (subCommandIndex !== undefined) {
-                    const baseSubCommand = `${parts[0]} ${parts[subCommandIndex]}`.toLowerCase();
-                    if (( commandsWithSubSubCommands.has(baseSubCommand))) {
-                        const subSubCommandIndex = findNextNonFlagArg(parts, subCommandIndex + 1);
-                        if (subSubCommandIndex !== undefined) {
-                            return parts.slice(0, subSubCommandIndex + 1).join(" ");
-                        }
-                        return undefined;
-                    } else {
-                        return parts.slice(0, subCommandIndex + 1).join(" ");
-                    }
-                }
-                return undefined;
-            } else {
-                return parts[0];
-            }
-        }))))));
-        if (subCommandsToSuggest.length > 0) {
-            let subCommandLabel;
-            if (subCommandsToSuggest.length === 1) {
-                subCommandLabel = `\`${subCommandsToSuggest[0]} \u2026\``;
-            } else {
-                subCommandLabel = `Commands ${( subCommandsToSuggest.map(e => `\`${e} \u2026\``)).join(", ")}`;
-            }
-            actions.push({
-                label: `Allow ${subCommandLabel} in this Session`,
-                data: {
-                    type: "newRule",
-                    rule: ( subCommandsToSuggest.map(key => ({
-                        key,
-                        value: true,
-                        scope: "session"
-                    })))
-                }
-            });
-            actions.push({
-                label: `Allow ${subCommandLabel} in this Workspace`,
-                data: {
-                    type: "newRule",
-                    rule: ( subCommandsToSuggest.map(key => ({
-                        key,
-                        value: true,
-                        scope: "workspace"
-                    })))
-                }
-            });
-            actions.push({
-                label: `Always Allow ${subCommandLabel}`,
-                data: {
-                    type: "newRule",
-                    rule: ( subCommandsToSuggest.map(key => ({
-                        key,
-                        value: true,
-                        scope: "user"
-                    })))
-                }
-            });
-        }
-        if (actions.length > 0) {
-            actions.push(( new Separator()));
-        }
-        const firstSubcommandFirstWord = unapprovedSubCommands.length > 0 ? unapprovedSubCommands[0].split(" ")[0] : "";
-        if (firstSubcommandFirstWord !== commandLine && !( commandsWithSubcommands.has(commandLine)) && !( commandsWithSubSubCommands.has(commandLine))) {
-            actions.push({
-                label: ( localize(13856, "Allow Exact Command Line in this Session")),
-                data: {
-                    type: "newRule",
-                    rule: {
-                        key: `/^${escapeRegExpCharacters(commandLine)}$/`,
-                        value: {
-                            approve: true,
-                            matchCommandLine: true
-                        },
-                        scope: "session"
-                    }
-                }
-            });
-            actions.push({
-                label: ( localize(13857, "Allow Exact Command Line in this Workspace")),
-                data: {
-                    type: "newRule",
-                    rule: {
-                        key: `/^${escapeRegExpCharacters(commandLine)}$/`,
-                        value: {
-                            approve: true,
-                            matchCommandLine: true
-                        },
-                        scope: "workspace"
-                    }
-                }
-            });
-            actions.push({
-                label: ( localize(13858, "Always Allow Exact Command Line")),
-                data: {
-                    type: "newRule",
-                    rule: {
-                        key: `/^${escapeRegExpCharacters(commandLine)}$/`,
-                        value: {
-                            approve: true,
-                            matchCommandLine: true
-                        },
-                        scope: "user"
-                    }
-                }
-            });
-        }
-    }
-    if (actions.length > 0) {
-        actions.push(( new Separator()));
-    }
-    actions.push({
-        label: ( localize(13859, "Allow All Commands in this Session")),
-        tooltip: ( localize(13860, "Allow this tool to run in this session without confirmation.")),
-        data: {
-            type: "sessionApproval"
-        }
-    });
-    actions.push(( new Separator()));
-    actions.push({
-        label: ( localize(13861, "Configure Auto Approve...")),
-        data: {
-            type: "configure"
-        }
-    });
-    return actions;
-}
-function dedupeRules(rules) {
-    return rules.filter((result, index, array) => {
-        if (!isAutoApproveRule(result.rule)) {
-            return false;
-        }
-        const sourceText = result.rule.sourceText;
-        return array.findIndex(r => isAutoApproveRule(r.rule) && r.rule.sourceText === sourceText) === index;
-    });
-}
-function extractCdPrefix(commandLine, shell, os) {
-    const isPwsh = isPowerShell(shell, os);
-    const cdPrefixMatch = commandLine.match(
-        isPwsh ? /^(?:cd(?: \/d)?|Set-Location(?: -Path)?) (?<dir>[^\s]+) ?(?:&&|;)\s+(?<suffix>.+)$/i : /^cd (?<dir>[^\s]+) &&\s+(?<suffix>.+)$/
-    );
-    const cdDir = cdPrefixMatch?.groups?.dir;
-    const cdSuffix = cdPrefixMatch?.groups?.suffix;
-    if (cdDir && cdSuffix) {
-        let cdDirPath = cdDir;
-        if (cdDirPath.startsWith("\"") && cdDirPath.endsWith("\"")) {
-            cdDirPath = cdDirPath.slice(1, -1);
-        }
-        return {
-            directory: cdDirPath,
-            command: cdSuffix
-        };
-    }
-    return undefined;
-}
-
-export { TRUNCATION_MESSAGE, dedupeRules, extractCdPrefix, generateAutoApproveActions, isBash, isFish, isPowerShell, isWindowsPowerShell, isZsh, normalizeTerminalCommandForDisplay, truncateOutputKeepingTail };