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

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,7 +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 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

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

@@ -1,52 +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;
-/**
- * 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

@@ -1,260 +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 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(14441, "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(14442, "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(14443, "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(14444, "Allow All Commands in this Session")),
-        tooltip: ( localize(14445, "Allow this tool to run in this session without confirmation.")),
-        data: {
-            type: "sessionApproval"
-        }
-    });
-    actions.push(( new Separator()));
-    actions.push({
-        label: ( localize(14446, "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

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