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

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 = 60000;
+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,52 @@
+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;
+/**
+ * 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;
+/**
+ * Whether a command spans multiple lines (heredoc, multi-statement block, etc.).
+ * Multi-line commands must be sent verbatim through bracketed paste mode so the
+ * shell treats them as a single paste instead of executing each line as it
+ * arrives.
+ *
+ * Bare line continuations (`\` immediately before a newline) are **not**
+ * considered multi-line because the shell joins them into a single logical
+ * line. Only newlines that are *not* preceded by a backslash count.
+ */
+export declare function isMultilineCommand(command: string): boolean;
+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

@@ -0,0 +1,260 @@
+
+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 buildCommandDisplayText(command) {
+    const normalized = normalizeTerminalCommandForDisplay(command).replace(/\r\n|\r|\n/g, " ");
+    return normalized.length > 80 ? normalized.substring(0, 77) + "..." : normalized;
+}
+function normalizeCommandForExecution(command) {
+    return command.replace(/\r\n|\r|\n/g, " ").trim();
+}
+function isMultilineCommand(command) {
+    const normalized = command.replace(/\r\n|\r/g, "\n");
+    return /(?<!\\)\n/.test(normalized);
+}
+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(14630, "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(14631, "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(14632, "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(14633, "Allow All Commands in this Session")),
+        tooltip: ( localize(14634, "Allow this tool to run in this session without confirmation.")),
+        data: {
+            type: "sessionApproval"
+        }
+    });
+    actions.push(( new Separator()));
+    actions.push({
+        label: ( localize(14635, "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, buildCommandDisplayText, dedupeRules, extractCdPrefix, generateAutoApproveActions, isBash, isFish, isMultilineCommand, isPowerShell, isWindowsPowerShell, isZsh, normalizeCommandForExecution, normalizeTerminalCommandForDisplay, truncateOutputKeepingTail };

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

@@ -0,0 +1,44 @@
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+import { ShellIntegrationQuality } from "./toolTerminalCreator.js";
+export declare class RunInTerminalToolTelemetry {
+    private readonly _telemetryService;
+    private readonly _configurationService;
+    constructor(_telemetryService: ITelemetryService, _configurationService: IConfigurationService);
+    logPrepare(state: {
+        terminalToolSessionId: string | undefined;
+        subCommands: string[];
+        autoApproveAllowed: "allowed" | "needsOptIn" | "off";
+        autoApproveResult: "approved" | "denied" | "manual";
+        autoApproveReason: "subCommand" | "commandLine" | undefined;
+        autoApproveDefault: boolean | undefined;
+    }): void;
+    logInvoke(instance: ITerminalInstance, state: {
+        terminalToolSessionId: string | undefined;
+        didUserEditCommand: boolean;
+        didToolEditCommand: boolean;
+        error: string | undefined;
+        isBackground: boolean;
+        isNewSession: boolean;
+        isSandboxWrapped: boolean;
+        requestUnsandboxedExecutionReason: string | undefined;
+        shellIntegrationQuality: ShellIntegrationQuality;
+        outputLineCount: number;
+        timingConnectMs: number;
+        timingExecuteMs: number;
+        pollDurationMs: number | undefined;
+        terminalExecutionIdleBeforeTimeout: boolean | undefined;
+        exitCode: number | undefined;
+        inputUserChars: number;
+        inputUserSigint: boolean;
+        inputToolManualAcceptCount: number | undefined;
+        inputToolManualRejectCount: number | undefined;
+        inputToolManualChars: number | undefined;
+        inputToolAutoAcceptCount: number | undefined;
+        inputToolAutoChars: number | undefined;
+        inputToolManualShownCount: number | undefined;
+        inputToolFreeFormInputShownCount: number | undefined;
+        inputToolFreeFormInputCount: number | undefined;
+    }): void;
+}