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

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

@@ -1,22 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ITerminalSandboxService } from "../../common/terminalSandboxService.js";
-import type { IOutputAnalyzer, IOutputAnalyzerOptions } from "./outputAnalyzer.js";
-export declare class SandboxOutputAnalyzer extends Disposable implements IOutputAnalyzer {
-    private readonly _sandboxService;
-    constructor(_sandboxService: ITerminalSandboxService);
-    analyze(options: IOutputAnalyzerOptions): Promise<string | undefined>;
-    /**
-     * Checks whether the command output contains strings that typically indicate
-     * the sandbox blocked the operation. Used when exit code is unavailable.
-     *
-     * The output may contain newlines inserted by terminal wrapping, so we
-     * strip them before testing.
-     */
-    private _outputLooksSandboxBlocked;
-}
-/**
- * Checks whether the command output contains strings that typically indicate
- * the sandbox blocked the operation. The output may contain newlines inserted
- * by terminal wrapping, so we strip them before testing.
- */
-export declare function outputLooksSandboxBlocked(output: string): boolean;

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

@@ -1,43 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import '../../common/terminalSandboxService.js';
-import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-import { AgentNetworkDomainSettingId } from '../../../../../../platform/networkFilter/common/settings.js';
-import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
-
-let SandboxOutputAnalyzer = class SandboxOutputAnalyzer extends Disposable {
-    constructor(_sandboxService) {
-        super();
-        this._sandboxService = _sandboxService;
-    }
-    async analyze(options) {
-        if (!options.isSandboxWrapped) {
-            return undefined;
-        }
-        const knownFailure = options.exitCode !== undefined && options.exitCode !== 0;
-        const suspectedFailure = !knownFailure && options.exitCode === undefined && this._outputLooksSandboxBlocked(options.exitResult);
-        if (!knownFailure && !suspectedFailure) {
-            return undefined;
-        }
-        const os = await this._sandboxService.getOS();
-        const fileSystemSetting = os === OperatingSystem.Linux ? TerminalChatAgentToolsSettingId.AgentSandboxLinuxFileSystem : TerminalChatAgentToolsSettingId.AgentSandboxMacFileSystem;
-        const prefix = knownFailure ? "Command failed while running in sandboxed mode. If the command failed due to sandboxing:" : "Command ran in sandboxed mode and may have been blocked by the sandbox. If the command failed due to sandboxing:";
-        return `${prefix}
-- If it would be reasonable to extend the sandbox rules, work with the user to update allowWrite for file system access problems in ${fileSystemSetting}, or to add required domains to ${AgentNetworkDomainSettingId.AllowedNetworkDomains}.
-- Otherwise, immediately retry the command with requestUnsandboxedExecution=true. Do NOT ask the user — setting this flag automatically shows a confirmation prompt to the user.
-
-Here is the output of the command:\n`;
-    }
-    _outputLooksSandboxBlocked(output) {
-        return outputLooksSandboxBlocked(output);
-    }
-};
-SandboxOutputAnalyzer = ( __decorate([( __param(0, ITerminalSandboxService))], SandboxOutputAnalyzer));
-function outputLooksSandboxBlocked(output) {
-    const normalized = output.replace(/\n/g, " ");
-    return /Operation not permitted|Permission denied|Read-only file system|sandbox-exec|bwrap|sandbox_violation/i.test(normalized);
-}
-
-export { SandboxOutputAnalyzer, outputLooksSandboxBlocked };

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

@@ -1,17 +0,0 @@
-import { IChatTerminalToolInvocationData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
-import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
-import { ITerminalLogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service";
-export declare class TerminalCommandArtifactCollector {
-    private readonly _logService;
-    constructor(_logService: ITerminalLogService);
-    capture(toolSpecificData: IChatTerminalToolInvocationData, instance: ITerminalInstance, commandId: string | undefined): Promise<void>;
-    private _captureCommandOutput;
-    /**
-     * Captures output from a partial/current command that hasn't finished yet.
-     * This is used when the command is cancelled mid-execution.
-     */
-    private _capturePartialCommandOutput;
-    private _applyTheme;
-    private _createTerminalCommandUri;
-    private _tryGetCommand;
-}

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

@@ -1,118 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { getCommandOutputSnapshot } from '../../../../terminal/browser/chatTerminalCommandMirror.js';
-import { TerminalCapability } 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';
-
-let TerminalCommandArtifactCollector = class TerminalCommandArtifactCollector {
-    constructor(_logService) {
-        this._logService = _logService;
-    }
-    async capture(toolSpecificData, instance, commandId) {
-        if (commandId) {
-            try {
-                toolSpecificData.terminalCommandUri = this._createTerminalCommandUri(instance, commandId);
-            } catch (error) {
-                this._logService.warn(
-                    `RunInTerminalTool: Failed to create terminal command URI for ${commandId}`,
-                    error
-                );
-            }
-            const command = await this._tryGetCommand(instance, commandId);
-            if (command) {
-                toolSpecificData.terminalCommandState = {
-                    exitCode: command.exitCode,
-                    timestamp: command.timestamp,
-                    duration: command.duration
-                };
-                const snapshot = await this._captureCommandOutput(instance, command);
-                if (snapshot) {
-                    toolSpecificData.terminalCommandOutput = snapshot;
-                }
-                this._applyTheme(toolSpecificData, instance);
-                return;
-            }
-            const partialSnapshot = await this._capturePartialCommandOutput(instance, commandId);
-            if (partialSnapshot) {
-                toolSpecificData.terminalCommandOutput = partialSnapshot;
-                this._logService.debug(`RunInTerminalTool: Captured partial command output for ${commandId}`);
-            }
-        }
-        this._applyTheme(toolSpecificData, instance);
-    }
-    async _captureCommandOutput(instance, command) {
-        try {
-            await instance.xtermReadyPromise;
-        } catch {
-            return undefined;
-        }
-        const xterm = instance.xterm;
-        if (!xterm) {
-            return undefined;
-        }
-        return getCommandOutputSnapshot(xterm, command, (reason, error) => {
-            const suffix = reason === "fallback" ? " (fallback)" : "";
-            this._logService.debug(`RunInTerminalTool: Failed to snapshot command output${suffix}`, error);
-        });
-    }
-    async _capturePartialCommandOutput(instance, commandId) {
-        try {
-            await instance.xtermReadyPromise;
-        } catch {
-            return undefined;
-        }
-        const xterm = instance.xterm;
-        if (!xterm) {
-            return undefined;
-        }
-        const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
-        const currentCommand = commandDetection?.currentCommand;
-        if (currentCommand && currentCommand.id === commandId) {
-            const executedMarker = currentCommand.commandExecutedMarker;
-            if (executedMarker && !executedMarker.isDisposed) {
-                try {
-                    const raw = xterm.raw;
-                    const buffer = raw.buffer.active;
-                    const endLine = buffer.baseY + buffer.cursorY;
-                    const startLine = executedMarker.line;
-                    const lineCount = Math.max(endLine - startLine, 0);
-                    if (lineCount > 0) {
-                        const text = await xterm.getRangeAsVT(executedMarker, undefined, true);
-                        if (text) {
-                            return {
-                                text,
-                                lineCount
-                            };
-                        }
-                    }
-                } catch (error) {
-                    this._logService.debug(`RunInTerminalTool: Failed to capture partial command output`, error);
-                }
-            }
-        }
-        return undefined;
-    }
-    _applyTheme(toolSpecificData, instance) {
-        const theme = instance.xterm?.getXtermTheme();
-        if (theme) {
-            toolSpecificData.terminalTheme = {
-                background: theme.background,
-                foreground: theme.foreground
-            };
-        }
-    }
-    _createTerminalCommandUri(instance, commandId) {
-        const params = ( new URLSearchParams(instance.resource.query));
-        params.set("command", commandId);
-        return instance.resource.with({
-            query: ( params.toString())
-        });
-    }
-    async _tryGetCommand(instance, commandId) {
-        const commandDetection = instance.capabilities.get(TerminalCapability.CommandDetection);
-        return commandDetection?.commands.find(c => c.id === commandId);
-    }
-};
-TerminalCommandArtifactCollector = ( __decorate([( __param(0, ITerminalLogService))], TerminalCommandArtifactCollector));
-
-export { TerminalCommandArtifactCollector };

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

@@ -1,22 +0,0 @@
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
-import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
-import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
-/**
- * Returns true if the chat session's permission level (Autopilot/Bypass Approvals)
- * auto-approves all tool calls, unless enterprise policy restricts it.
- * Checks both the request-stamped level and the live picker level.
- */
-export declare function isSessionAutoApproveLevel(chatSessionResource: URI, configurationService: IConfigurationService, chatWidgetService: IChatWidgetService, chatService: IChatService): boolean;
-/**
- * Checks whether a terminal tool is eligible for auto-approval based on user configuration.
- * @param toolReferenceName The tool's reference name (e.g. 'runInTerminal', 'sendToTerminal').
- * @param legacyToolReferenceFullNames Legacy names to check for backward compatibility.
- */
-export declare function isToolEligibleForTerminalAutoApproval(toolReferenceName: string, configurationService: IConfigurationService, legacyToolReferenceFullNames?: string[]): boolean;
-/**
- * Determines whether terminal auto-approve rules are allowed to take effect.
- * This checks the setting enablement, the opt-in warning acceptance, and the per-tool eligibility.
- */
-export declare function isTerminalAutoApproveAllowed(toolReferenceName: string, configurationService: IConfigurationService, storageService: IStorageService, legacyToolReferenceFullNames?: string[]): boolean;

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

@@ -1,44 +0,0 @@
-
-import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { TerminalToolConfirmationStorageKeys } from '../../../../chat/browser/widget/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
-import { ChatConfiguration, isAutoApproveLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
-
-function isSessionAutoApproveLevel(chatSessionResource, configurationService, chatWidgetService, chatService) {
-    const inspected = configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
-    if (inspected.policyValue === false) {
-        return false;
-    }
-    const widget = chatWidgetService.getWidgetBySessionResource(chatSessionResource)
-        ?? chatWidgetService.lastFocusedWidget;
-    if (widget && isAutoApproveLevel(widget.input.currentModeInfo.permissionLevel)) {
-        return true;
-    }
-    const model = chatService.getSession(chatSessionResource);
-    const request = model?.getRequests().at(-1);
-    return isAutoApproveLevel(request?.modeInfo?.permissionLevel);
-}
-function isToolEligibleForTerminalAutoApproval(toolReferenceName, configurationService, legacyToolReferenceFullNames) {
-    const config = configurationService.getValue(ChatConfiguration.EligibleForAutoApproval);
-    if (config && typeof config === 'object') {
-        if (Object.prototype.hasOwnProperty.call(config, toolReferenceName)) {
-            return config[toolReferenceName];
-        }
-        if (legacyToolReferenceFullNames) {
-            for (const legacyName of legacyToolReferenceFullNames) {
-                if (Object.prototype.hasOwnProperty.call(config, legacyName)) {
-                    return config[legacyName];
-                }
-            }
-        }
-    }
-    return true;
-}
-function isTerminalAutoApproveAllowed(toolReferenceName, configurationService, storageService, legacyToolReferenceFullNames) {
-    const isEligible = isToolEligibleForTerminalAutoApproval(toolReferenceName, configurationService, legacyToolReferenceFullNames);
-    const isAutoApproveEnabled = configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
-    const isAutoApproveWarningAccepted = storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
-    return isEligible && isAutoApproveEnabled && isAutoApproveWarningAccepted;
-}
-
-export { isSessionAutoApproveLevel, isTerminalAutoApproveAllowed, isToolEligibleForTerminalAutoApproval };

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

@@ -1 +0,0 @@
-export { TerminalToolId } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/terminalToolIds";

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

@@ -1,58 +0,0 @@
-import type { QueryCapture } from "@codingame/monaco-vscode-api/external/@vscode/tree-sitter-wasm/wasm/tree-sitter";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ITreeSitterLibraryService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterLibraryService.service";
-import type { ITerminalSandboxCommand } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
-export declare enum TreeSitterCommandParserLanguage {
-    Bash = "bash",
-    PowerShell = "powershell"
-}
-export declare class TreeSitterCommandParser extends Disposable {
-    private readonly _treeSitterLibraryService;
-    private readonly _parser;
-    private readonly _treeCache;
-    private readonly _commandFileWriteParsers;
-    constructor(_treeSitterLibraryService: ITreeSitterLibraryService);
-    extractSubCommands(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
-    extractPwshDoubleAmpersandChainOperators(commandLine: string): Promise<QueryCapture[]>;
-    /**
-     * Extracts executable command invocations from the command line and returns
-     * normalized command details for sandbox allow-listing.
-     *
-     * Example: `PATH=/bin /usr/bin/git commit -S -m "test" && npm install`
-     * returns:
-     * `[
-     * 	{ keyword: 'git', args: ['commit', '-S', '-m', 'test'] },
-     * 	{ keyword: 'npm', args: ['install'] }
-     * ]`.
-     */
-    extractCommands(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<ITerminalSandboxCommand[]>;
-    getFileWrites(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
-    /**
-     * Extracts file targets from commands that perform file writes beyond shell redirections.
-     * Uses registered command parsers (e.g., for `sed -i`) to detect command-specific file writes.
-     * Returns an array of file paths that would be modified.
-     */
-    getCommandFileWrites(languageId: TreeSitterCommandParserLanguage, commandLine: string): Promise<string[]>;
-    private _queryTree;
-    /**
-     * Converts a command token to the stable keyword used by sandbox allow-list
-     * rules by stripping quotes, path segments, and common executable suffixes.
-     */
-    private _normalizeCommandKeyword;
-    /**
-     * Parses a single tree-sitter command node into command details, ignoring
-     * leading environment variable assignments such as `NODE_ENV=test npm run build`.
-     */
-    private _parseCommand;
-    /**
-     * Splits enough shell syntax for sandbox allow-listing: whitespace separates
-     * tokens, quotes are removed, and backslash escapes preserve the escaped char.
-     */
-    private _splitCommandTokens;
-    /**
-     * Returns true for simple shell-style environment variable assignments that
-     * can prefix a command invocation.
-     */
-    private _isVariableAssignment;
-    private _doQuery;
-}

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

@@ -1,223 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { BugIndicatingError, ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
-import { Disposable, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import { ITreeSitterLibraryService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitter/treeSitterLibraryService.service';
-import { SedFileWriteParser } from './commandParsers/sedFileWriteParser.js';
-
-var TreeSitterCommandParserLanguage;
-(function(TreeSitterCommandParserLanguage) {
-    TreeSitterCommandParserLanguage["Bash"] = "bash";
-    TreeSitterCommandParserLanguage["PowerShell"] = "powershell";
-})(TreeSitterCommandParserLanguage || (TreeSitterCommandParserLanguage = {}));
-const pwshFlagEqualsRegex = /(^|\s)(-{1,2}[\w-]+)=/g;
-function maskPwshFlagEquals(commandLine) {
-    return commandLine.replace(pwshFlagEqualsRegex, (_, pre, flag) => `${pre}${flag} `);
-}
-let TreeSitterCommandParser = class TreeSitterCommandParser extends Disposable {
-    constructor(_treeSitterLibraryService) {
-        super();
-        this._treeSitterLibraryService = _treeSitterLibraryService;
-        this._treeCache = this._register(( new TreeCache()));
-        this._commandFileWriteParsers = [( new SedFileWriteParser())];
-        this._parser = ( new Lazy(
-            () => this._treeSitterLibraryService.getParserClass().then(ParserCtor => ( new ParserCtor()))
-        ));
-    }
-    async extractSubCommands(languageId, commandLine) {
-        if (languageId === TreeSitterCommandParserLanguage.PowerShell) {
-            const masked = maskPwshFlagEquals(commandLine);
-            if (masked !== commandLine) {
-                const captures = await this._queryTree(languageId, masked, "(command) @command");
-                return ( captures.map(e => commandLine.substring(e.node.startIndex, e.node.endIndex)));
-            }
-        }
-        const captures = await this._queryTree(languageId, commandLine, "(command) @command");
-        return ( captures.map(e => e.node.text));
-    }
-    async extractPwshDoubleAmpersandChainOperators(commandLine) {
-        const captures = await this._queryTree(
-            TreeSitterCommandParserLanguage.PowerShell,
-            commandLine,
-            ["(", "  (pipeline", "    (pipeline_chain_tail) @double.ampersand)", ")"].join("\n")
-        );
-        return captures;
-    }
-    async extractCommands(languageId, commandLine) {
-        const commands = [];
-        for (const commandText of await this.extractSubCommands(languageId, commandLine)) {
-            const command = this._parseCommand(commandText);
-            if (command) {
-                commands.push(command);
-            }
-        }
-        return commands;
-    }
-    async getFileWrites(languageId, commandLine) {
-        let query;
-        switch (languageId) {
-        case TreeSitterCommandParserLanguage.Bash:
-            query = [
-                "(file_redirect",
-                "  destination: [(word) (string (string_content)) (raw_string) (concatenation)] @file)"
-            ].join("\n");
-            break;
-        case TreeSitterCommandParserLanguage.PowerShell:
-            query = ["(redirection", "  (redirected_file_name) @file)"].join("\n");
-            break;
-        }
-        const captures = await this._queryTree(languageId, commandLine, query);
-        return ( captures.map(e => e.node.text.trim()));
-    }
-    async getCommandFileWrites(languageId, commandLine) {
-        if (languageId !== TreeSitterCommandParserLanguage.Bash) {
-            return [];
-        }
-        const query = "(command) @command";
-        const captures = await this._queryTree(languageId, commandLine, query);
-        const result = [];
-        for (const capture of captures) {
-            const commandText = capture.node.text;
-            for (const parser of this._commandFileWriteParsers) {
-                if (parser.canHandle(commandText)) {
-                    result.push(...parser.extractFileWrites(commandText));
-                }
-            }
-        }
-        return result;
-    }
-    async _queryTree(languageId, commandLine, querySource) {
-        const {
-            tree,
-            query
-        } = await this._doQuery(languageId, commandLine, querySource);
-        return query.captures(tree.rootNode);
-    }
-    _normalizeCommandKeyword(token) {
-        const unquoted = token.replace(/^['"]|['"]$/g, "");
-        if (!unquoted) {
-            return undefined;
-        }
-        const pathBase = unquoted.includes("\\") ? win32.basename(unquoted) : posix.basename(unquoted);
-        const normalized = pathBase.toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/i, "");
-        return normalized || undefined;
-    }
-    _parseCommand(commandText) {
-        const tokens = this._splitCommandTokens(commandText);
-        let commandIndex = 0;
-        while (commandIndex < tokens.length && this._isVariableAssignment(tokens[commandIndex])) {
-            commandIndex++;
-        }
-        const keyword = this._normalizeCommandKeyword(tokens[commandIndex] ?? "");
-        if (!keyword) {
-            return undefined;
-        }
-        return {
-            keyword,
-            args: tokens.slice(commandIndex + 1)
-        };
-    }
-    _splitCommandTokens(commandText) {
-        const tokens = [];
-        let current = "";
-        let quote;
-        let escaping = false;
-        for (const char of commandText.trim()) {
-            if (escaping) {
-                current += char;
-                escaping = false;
-                continue;
-            }
-            if (char === "\\" && quote !== "'") {
-                escaping = true;
-                continue;
-            }
-            if (quote) {
-                if (char === quote) {
-                    quote = undefined;
-                } else {
-                    current += char;
-                }
-                continue;
-            }
-            if (char === "'" || char === "\"") {
-                quote = char;
-                continue;
-            }
-            if (/\s/.test(char)) {
-                if (current) {
-                    tokens.push(current);
-                    current = "";
-                }
-                continue;
-            }
-            current += char;
-        }
-        if (escaping) {
-            current += "\\";
-        }
-        if (current) {
-            tokens.push(current);
-        }
-        return tokens;
-    }
-    _isVariableAssignment(token) {
-        return /^[A-Za-z_][A-Za-z0-9_]*=.*/.test(token);
-    }
-    async _doQuery(languageId, commandLine, querySource) {
-        const language = await this._treeSitterLibraryService.getLanguagePromise(languageId);
-        if (!language) {
-            throw ( new BugIndicatingError("Failed to fetch language grammar"));
-        }
-        let tree = this._treeCache.get(languageId, commandLine);
-        if (!tree) {
-            const parser = await this._parser.value;
-            parser.setLanguage(language);
-            const parsedTree = parser.parse(commandLine);
-            if (!parsedTree) {
-                throw ( new ErrorNoTelemetry("Failed to parse tree"));
-            }
-            tree = parsedTree;
-            this._treeCache.set(languageId, commandLine, tree);
-        }
-        const query = await this._treeSitterLibraryService.createQuery(language, querySource);
-        if (!query) {
-            throw ( new BugIndicatingError("Failed to create tree sitter query"));
-        }
-        return {
-            tree,
-            query
-        };
-    }
-};
-TreeSitterCommandParser = ( __decorate([( __param(0, ITreeSitterLibraryService))], TreeSitterCommandParser));
-class TreeCache extends Disposable {
-    constructor() {
-        super();
-        this._cache = ( new Map());
-        this._clearScheduler = this._register(( new MutableDisposable()));
-        this._register(toDisposable(() => this._cache.clear()));
-    }
-    get(languageId, commandLine) {
-        this._resetClearTimer();
-        return this._cache.get(this._getCacheKey(languageId, commandLine));
-    }
-    set(languageId, commandLine, tree) {
-        this._resetClearTimer();
-        this._cache.set(this._getCacheKey(languageId, commandLine), tree);
-    }
-    _getCacheKey(languageId, commandLine) {
-        return `${languageId}:${commandLine}`;
-    }
-    _resetClearTimer() {
-        this._clearScheduler.value = ( new RunOnceScheduler(() => {
-            this._cache.clear();
-        }, 10000));
-        this._clearScheduler.value.schedule();
-    }
-}
-
-export { TreeSitterCommandParser, TreeSitterCommandParserLanguage };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxCommandRules.d.ts

@@ -1,31 +0,0 @@
-import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
-import type { ITerminalSandboxCommand } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
-export interface ITerminalSandboxCommandRuleContext {
-    readonly os: OperatingSystem;
-}
-export interface ITerminalSandboxCommandRule<T> {
-    readonly keywords: readonly string[];
-    readonly value: T;
-    readonly subcommands?: readonly string[];
-    readonly optionsWithValue?: ReadonlySet<string>;
-    /** Context-wide guard for rules, such as OS-specific sandbox capabilities. */
-    readonly condition?: (context: ITerminalSandboxCommandRuleContext) => boolean;
-    /** Command-specific guard for argument-sensitive rules. */
-    readonly when?: (command: ITerminalSandboxCommand) => boolean;
-}
-/**
- * Git global options that consume the following argument. These need to be
- * skipped when finding the subcommand so `git -C repo commit` matches `commit`
- * instead of treating `repo` as the subcommand.
- */
-export declare const gitGlobalOptionsWithValue: Set<string>;
-export declare function matchesTerminalSandboxCommandRule<T>(command: ITerminalSandboxCommand, rule: ITerminalSandboxCommandRule<T>, context?: ITerminalSandboxCommandRuleContext): boolean;
-/**
- * Returns the first non-option argument, treating it as the command's subcommand.
- * Options are skipped, and options listed in `optionsWithValue` also skip the
- * following argument so global option values are not mistaken for subcommands.
- *
- * For example, with `-C` in `optionsWithValue`, `git -C repo commit` returns
- * `commit` instead of `repo`.
- */
-export declare function getCommandSubcommand(args: readonly string[], optionsWithValue?: ReadonlySet<string>): string | undefined;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxCommandRules.js

@@ -1,49 +0,0 @@
-
-
-const gitGlobalOptionsWithValue = ( new Set([
-    "-C",
-    "-c",
-    "--config-env",
-    "--exec-path",
-    "--git-dir",
-    "--html-path",
-    "--info-path",
-    "--man-path",
-    "--namespace",
-    "--super-prefix",
-    "--work-tree"
-]));
-function matchesTerminalSandboxCommandRule(command, rule, context) {
-    if (!rule.keywords.includes(command.keyword.toLowerCase())) {
-        return false;
-    }
-    if (rule.condition && (!context || !rule.condition(context))) {
-        return false;
-    }
-    if (rule.subcommands) {
-        const subcommand = getCommandSubcommand(command.args, rule.optionsWithValue);
-        if (subcommand === undefined || !rule.subcommands.includes(subcommand)) {
-            return false;
-        }
-    }
-    return rule.when?.(command) ?? true;
-}
-function getCommandSubcommand(args, optionsWithValue) {
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === "--") {
-            return undefined;
-        }
-        if (arg.startsWith("-")) {
-            const option = arg.includes("=") ? arg.substring(0, arg.indexOf("=")) : arg;
-            if (!arg.includes("=") && optionsWithValue?.has(option)) {
-                i++;
-            }
-            continue;
-        }
-        return arg.toLowerCase();
-    }
-    return undefined;
-}
-
-export { getCommandSubcommand, gitGlobalOptionsWithValue, matchesTerminalSandboxCommandRule };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalSandboxReadAllowList.d.ts

@@ -1,18 +0,0 @@
-import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
-import type { ITerminalSandboxCommand } from "../../../../../platform/sandbox/common/terminalSandboxService.js";
-export declare enum TerminalSandboxReadAllowListOperation {
-    Git = "git",
-    Node = "node",
-    Rust = "rust",
-    Go = "go",
-    Python = "python",
-    Java = "java",
-    Dotnet = "dotnet",
-    Nuget = "nuget",
-    Msbuild = "msbuild",
-    Ruby = "ruby",
-    NativeBuild = "nativeBuild",
-    Conan = "conan",
-    GnuPG = "gnupg"
-}
-export declare function getTerminalSandboxReadAllowListForCommands(os: OperatingSystem, commandKeywords: readonly string[], commandDetails?: readonly ITerminalSandboxCommand[]): readonly string[];