@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.0

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

@@ -0,0 +1,168 @@
+
+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 { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { win32, posix } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { TreeSitterCommandParserLanguage } from '../../treeSitterCommandParser.js';
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { isString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+
+const nullDevice = Symbol("null device");
+let CommandLineFileWriteAnalyzer = class CommandLineFileWriteAnalyzer extends Disposable {
+    constructor(
+        _treeSitterCommandParser,
+        _log,
+        _configurationService,
+        _labelService,
+        _workspaceContextService
+    ) {
+        super();
+        this._treeSitterCommandParser = _treeSitterCommandParser;
+        this._log = _log;
+        this._configurationService = _configurationService;
+        this._labelService = _labelService;
+        this._workspaceContextService = _workspaceContextService;
+    }
+    async analyze(options) {
+        let fileWrites;
+        try {
+            fileWrites = await this._getFileWrites(options);
+        } catch (e) {
+            console.error(e);
+            this._log("Failed to get file writes via grammar", options.treeSitterLanguage);
+            return {
+                isAutoApproveAllowed: false
+            };
+        }
+        return this._getResult(options, fileWrites);
+    }
+    async _getFileWrites(options) {
+        let fileWrites = [];
+        const capturedFileWrites = ( (await this._treeSitterCommandParser.getFileWrites(options.treeSitterLanguage, options.commandLine)).map(this._mapNullDevice.bind(this, options)));
+        const commandFileWrites = ( (await this._treeSitterCommandParser.getCommandFileWrites(options.treeSitterLanguage, options.commandLine)).map(this._mapNullDevice.bind(this, options)));
+        const allCapturedFileWrites = [...capturedFileWrites, ...commandFileWrites];
+        if (allCapturedFileWrites.length) {
+            const cwd = options.cwd;
+            if (cwd) {
+                this._log("Detected cwd", ( cwd.toString()));
+                fileWrites = ( allCapturedFileWrites.map(e => {
+                    if (e === nullDevice) {
+                        return e;
+                    }
+                    if (/^['"].*['"]$/.test(e)) {
+                        e = this._stripSurroundingQuotes(e);
+                    }
+                    const isAbsolute = options.os === OperatingSystem.Windows ? win32.isAbsolute(e) : posix.isAbsolute(e);
+                    if (isAbsolute) {
+                        return cwd.with({
+                            path: e
+                        });
+                    }
+                    return URI.joinPath(cwd, e);
+                }));
+            } else {
+                this._log("Cwd could not be detected");
+                fileWrites = allCapturedFileWrites;
+            }
+        }
+        this._log("File writes detected", ( fileWrites.map(e => ( e.toString()))));
+        return fileWrites;
+    }
+    _stripSurroundingQuotes(text) {
+        if ((text.startsWith("\"") && text.endsWith("\"")) || (text.startsWith("'") && text.endsWith("'"))) {
+            return text.slice(1, -1);
+        }
+        return text;
+    }
+    _mapNullDevice(options, rawFileWrite) {
+        if (options.treeSitterLanguage === TreeSitterCommandParserLanguage.PowerShell) {
+            return rawFileWrite === "$null" ? nullDevice : rawFileWrite;
+        }
+        return rawFileWrite === "/dev/null" ? nullDevice : rawFileWrite;
+    }
+    _getResult(options, fileWrites) {
+        let isAutoApproveAllowed = true;
+        if (fileWrites.length > 0) {
+            const blockDetectedFileWrites = this._configurationService.getValue(TerminalChatAgentToolsSettingId.BlockDetectedFileWrites);
+            switch (blockDetectedFileWrites) {
+            case "all":
+                {
+                    isAutoApproveAllowed = false;
+                    this._log("File writes blocked due to \"all\" setting");
+                    break;
+                }
+            case "outsideWorkspace":
+                {
+                    const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
+                    if (workspaceFolders.length > 0) {
+                        for (const fileWrite of fileWrites) {
+                            if (fileWrite === nullDevice) {
+                                this._log("File write to null device allowed", URI.isUri(fileWrite) ? ( fileWrite.toString()) : fileWrite);
+                                continue;
+                            }
+                            if (isString(fileWrite)) {
+                                const isAbsolute = options.os === OperatingSystem.Windows ? win32.isAbsolute(fileWrite) : posix.isAbsolute(fileWrite);
+                                if (!isAbsolute) {
+                                    isAutoApproveAllowed = false;
+                                    this._log("File write blocked due to unknown terminal cwd", fileWrite);
+                                    break;
+                                }
+                            }
+                            const fileUri = URI.isUri(fileWrite) ? fileWrite : URI.file(fileWrite);
+                            if (fileUri.fsPath.match(/[$\(\){}`]/)) {
+                                isAutoApproveAllowed = false;
+                                this._log(
+                                    "File write blocked due to likely containing a variable or sub-command",
+                                    ( fileUri.toString())
+                                );
+                                break;
+                            }
+                            const isInsideWorkspace = ( workspaceFolders.some(
+                                folder => folder.uri.scheme === fileUri.scheme && (fileUri.path.startsWith(folder.uri.path + "/") || fileUri.path === folder.uri.path)
+                            ));
+                            if (!isInsideWorkspace) {
+                                isAutoApproveAllowed = false;
+                                this._log("File write blocked outside workspace", ( fileUri.toString()));
+                                break;
+                            }
+                        }
+                    } else {
+                        const hasOnlyNullDevices = fileWrites.every(fw => fw === nullDevice);
+                        if (!hasOnlyNullDevices) {
+                            isAutoApproveAllowed = false;
+                            this._log("File writes blocked - no workspace folders");
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        const disclaimers = [];
+        if (fileWrites.length > 0) {
+            const fileWritesList = ( fileWrites.map(
+                fw => `\`${URI.isUri(fw) ? this._labelService.getUriLabel(fw) : fw === nullDevice ? "/dev/null" : ( fw.toString())}\``
+            )).join(", ");
+            if (!isAutoApproveAllowed) {
+                disclaimers.push(( localize(
+                    14017,
+                    "File write operations detected that cannot be auto approved: {0}",
+                    fileWritesList
+                )));
+            } else {
+                disclaimers.push(( localize(14018, "File write operations detected: {0}", fileWritesList)));
+            }
+        }
+        return {
+            isAutoApproveAllowed,
+            disclaimers
+        };
+    }
+};
+CommandLineFileWriteAnalyzer = ( __decorate([( __param(2, IConfigurationService)), ( __param(3, ILabelService)), ( __param(4, IWorkspaceContextService))], CommandLineFileWriteAnalyzer));
+
+export { CommandLineFileWriteAnalyzer };

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

@@ -0,0 +1,11 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ITerminalSandboxService } from "../../../common/terminalSandboxService.js";
+import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from "./commandLineAnalyzer.js";
+export declare class CommandLineSandboxAnalyzer extends Disposable implements ICommandLineAnalyzer {
+    private readonly _sandboxService;
+    private readonly _configurationService;
+    constructor(_sandboxService: ITerminalSandboxService, _configurationService: IConfigurationService);
+    private _isAutoApproveEnabled;
+    analyze(_options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
+}

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

@@ -0,0 +1,33 @@
+
+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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import '../../../common/terminalSandboxService.js';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
+
+let CommandLineSandboxAnalyzer = class CommandLineSandboxAnalyzer extends Disposable {
+    constructor(_sandboxService, _configurationService) {
+        super();
+        this._sandboxService = _sandboxService;
+        this._configurationService = _configurationService;
+    }
+    _isAutoApproveEnabled() {
+        return this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) !== false;
+    }
+    async analyze(_options) {
+        const isAutoApproveEnabled = this._isAutoApproveEnabled();
+        if (!(await this._sandboxService.isEnabled())) {
+            return {
+                isAutoApproveAllowed: isAutoApproveEnabled
+            };
+        }
+        return {
+            isAutoApproveAllowed: isAutoApproveEnabled,
+            forceAutoApproval: !_options.requiresUnsandboxConfirmation && isAutoApproveEnabled
+        };
+    }
+};
+CommandLineSandboxAnalyzer = ( __decorate([( __param(0, ITerminalSandboxService)), ( __param(1, IConfigurationService))], CommandLineSandboxAnalyzer));
+
+export { CommandLineSandboxAnalyzer };

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

@@ -0,0 +1,41 @@
+import type { MaybePromise } from "@codingame/monaco-vscode-api/vscode/vs/base/common/async";
+import type { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+export interface ICommandLinePresenter {
+    /**
+     * Attempts to create a presentation for the given command line.
+     * Command line presenters allow displaying an extracted/transformed version
+     * of a command (e.g., Python code from `python -c "..."`) with appropriate
+     * syntax highlighting, while the actual command remains unchanged.
+     *
+     * @returns The presentation result if this presenter handles the command, undefined otherwise.
+     */
+    present(options: ICommandLinePresenterOptions): MaybePromise<ICommandLinePresenterResult | undefined>;
+}
+export interface ICommandLinePresenterOptions {
+    commandLine: ICommandLinePresentationInput;
+    shell: string;
+    os: OperatingSystem;
+}
+export interface ICommandLinePresentationInput {
+    original?: string;
+    forDisplay: string;
+}
+export interface ICommandLinePresenterResult {
+    /**
+     * The extracted/transformed command to display (e.g., the Python code).
+     */
+    commandLine: string;
+    /**
+     * The language ID for syntax highlighting (e.g., 'python').
+     */
+    language?: string;
+    /**
+     * A human-readable name for the language (e.g., 'Python') used in UI labels.
+     */
+    languageDisplayName?: string;
+    /**
+     *  Whether other presenters should still process the command line.
+     * Defaults to false - once a presenter handles a command, no further processing is done.
+     */
+    processOtherPresenters?: boolean;
+}

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

@@ -0,0 +1,19 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
+/**
+ * Command line presenter for Node.js inline commands (`node -e "..."`).
+ * Extracts the JavaScript code and sets up JavaScript syntax highlighting.
+ */
+export declare class NodeCommandLinePresenter implements ICommandLinePresenter {
+    present(options: ICommandLinePresenterOptions): ICommandLinePresenterResult | undefined;
+}
+/**
+ * Extracts the JavaScript code from a `node -e "..."` or `node -e '...'` command,
+ * returning the code with properly unescaped quotes.
+ *
+ * @param commandLine The full command line to parse
+ * @param shell The shell path (to determine quote escaping style)
+ * @param os The operating system
+ * @returns The extracted JavaScript code, or undefined if not a node -e/--eval command
+ */
+export declare function extractNodeCommand(commandLine: string, shell: string, os: OperatingSystem): string | undefined;

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

@@ -0,0 +1,37 @@
+
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+
+class NodeCommandLinePresenter {
+    present(options) {
+        const commandLine = options.commandLine.forDisplay;
+        const extractedNode = extractNodeCommand(commandLine, options.shell, options.os);
+        if (extractedNode) {
+            return {
+                commandLine: extractedNode,
+                language: 'javascript',
+                languageDisplayName: 'Node.js',
+            };
+        }
+        return undefined;
+    }
+}
+function extractNodeCommand(commandLine, shell, os) {
+    const doubleQuoteMatch = commandLine.match(/^node(?:js)?\s+(?:-e|--eval)\s+"(?<code>.+)"$/s);
+    if (doubleQuoteMatch?.groups?.code) {
+        let jsCode = doubleQuoteMatch.groups.code.trim();
+        if (isPowerShell(shell, os)) {
+            jsCode = jsCode.replace(/`"/g, '"');
+        }
+        else {
+            jsCode = jsCode.replace(/\\"/g, '"');
+        }
+        return jsCode;
+    }
+    const singleQuoteMatch = commandLine.match(/^node(?:js)?\s+(?:-e|--eval)\s+'(?<code>.+)'$/s);
+    if (singleQuoteMatch?.groups?.code) {
+        return singleQuoteMatch.groups.code.trim();
+    }
+    return undefined;
+}
+
+export { NodeCommandLinePresenter, extractNodeCommand };

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

@@ -0,0 +1,19 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
+/**
+ * Command line presenter for Python inline commands (`python -c "..."`).
+ * Extracts the Python code and sets up Python syntax highlighting.
+ */
+export declare class PythonCommandLinePresenter implements ICommandLinePresenter {
+    present(options: ICommandLinePresenterOptions): ICommandLinePresenterResult | undefined;
+}
+/**
+ * Extracts the Python code from a `python -c "..."` or `python -c '...'` command,
+ * returning the code with properly unescaped quotes.
+ *
+ * @param commandLine The full command line to parse
+ * @param shell The shell path (to determine quote escaping style)
+ * @param os The operating system
+ * @returns The extracted Python code, or undefined if not a python -c command
+ */
+export declare function extractPythonCommand(commandLine: string, shell: string, os: OperatingSystem): string | undefined;

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

@@ -0,0 +1,37 @@
+
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+
+class PythonCommandLinePresenter {
+    present(options) {
+        const commandLine = options.commandLine.forDisplay;
+        const extractedPython = extractPythonCommand(commandLine, options.shell, options.os);
+        if (extractedPython) {
+            return {
+                commandLine: extractedPython,
+                language: 'python',
+                languageDisplayName: 'Python',
+            };
+        }
+        return undefined;
+    }
+}
+function extractPythonCommand(commandLine, shell, os) {
+    const doubleQuoteMatch = commandLine.match(/^python(?:3)?\s+-c\s+"(?<python>.+)"$/s);
+    if (doubleQuoteMatch?.groups?.python) {
+        let pythonCode = doubleQuoteMatch.groups.python.trim();
+        if (isPowerShell(shell, os)) {
+            pythonCode = pythonCode.replace(/`"/g, '"');
+        }
+        else {
+            pythonCode = pythonCode.replace(/\\"/g, '"');
+        }
+        return pythonCode;
+    }
+    const singleQuoteMatch = commandLine.match(/^python(?:3)?\s+-c\s+'(?<python>.+)'$/s);
+    if (singleQuoteMatch?.groups?.python) {
+        return singleQuoteMatch.groups.python.trim();
+    }
+    return undefined;
+}
+
+export { PythonCommandLinePresenter, extractPythonCommand };

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

@@ -0,0 +1,19 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
+/**
+ * Command line presenter for Ruby inline commands (`ruby -e "..."`).
+ * Extracts the Ruby code and sets up Ruby syntax highlighting.
+ */
+export declare class RubyCommandLinePresenter implements ICommandLinePresenter {
+    present(options: ICommandLinePresenterOptions): ICommandLinePresenterResult | undefined;
+}
+/**
+ * Extracts the Ruby code from a `ruby -e "..."` or `ruby -e '...'` command,
+ * returning the code with properly unescaped quotes.
+ *
+ * @param commandLine The full command line to parse
+ * @param shell The shell path (to determine quote escaping style)
+ * @param os The operating system
+ * @returns The extracted Ruby code, or undefined if not a ruby -e command
+ */
+export declare function extractRubyCommand(commandLine: string, shell: string, os: OperatingSystem): string | undefined;

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

@@ -0,0 +1,44 @@
+
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+
+class RubyCommandLinePresenter {
+    present(options) {
+        const commandLine = options.commandLine.forDisplay;
+        const extractedRuby = extractRubyCommand(commandLine, options.shell, options.os);
+        if (extractedRuby) {
+            return {
+                commandLine: extractedRuby,
+                language: 'ruby',
+                languageDisplayName: 'Ruby',
+            };
+        }
+        return undefined;
+    }
+}
+function extractRubyCommand(commandLine, shell, os) {
+    const doubleQuoteMatch = commandLine.match(/^ruby\s+-e\s+"(?<code>.+)"$/s);
+    if (doubleQuoteMatch?.groups?.code) {
+        let rubyCode = doubleQuoteMatch.groups.code.trim();
+        if (!rubyCode) {
+            return undefined;
+        }
+        if (isPowerShell(shell, os)) {
+            rubyCode = rubyCode.replace(/`"/g, '"');
+        }
+        else {
+            rubyCode = rubyCode.replace(/\\"/g, '"');
+        }
+        return rubyCode;
+    }
+    const singleQuoteMatch = commandLine.match(/^ruby\s+-e\s+'(?<code>.+)'$/s);
+    if (singleQuoteMatch?.groups?.code) {
+        const rubyCode = singleQuoteMatch.groups.code.trim();
+        if (!rubyCode) {
+            return undefined;
+        }
+        return rubyCode;
+    }
+    return undefined;
+}
+
+export { RubyCommandLinePresenter, extractRubyCommand };

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

@@ -0,0 +1,13 @@
+import { ITerminalSandboxService } from "../../../common/terminalSandboxService.js";
+import type { ICommandLinePresenter, ICommandLinePresenterOptions, ICommandLinePresenterResult } from "./commandLinePresenter.js";
+/**
+ * Command line presenter for sandboxed commands.
+ * Returns the display form of the command (provided via {@link ICommandLineRewriterResult.forDisplay}
+ * from the rewriter pipeline) for cleaner presentation, while the actual sandboxed command runs
+ * unchanged.
+ */
+export declare class SandboxedCommandLinePresenter implements ICommandLinePresenter {
+    private readonly _sandboxService;
+    constructor(_sandboxService: ITerminalSandboxService);
+    present(options: ICommandLinePresenterOptions): Promise<ICommandLinePresenterResult | undefined>;
+}

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

@@ -0,0 +1,22 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '../../../common/terminalSandboxService.js';
+import { ITerminalSandboxService } from '@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service';
+
+let SandboxedCommandLinePresenter = class SandboxedCommandLinePresenter {
+    constructor(_sandboxService) {
+        this._sandboxService = _sandboxService;
+    }
+    async present(options) {
+        if (!(await this._sandboxService.isEnabled())) {
+            return undefined;
+        }
+        return {
+            commandLine: options.commandLine.forDisplay,
+            processOtherPresenters: true
+        };
+    }
+};
+SandboxedCommandLinePresenter = ( __decorate([( __param(0, ITerminalSandboxService))], SandboxedCommandLinePresenter));
+
+export { SandboxedCommandLinePresenter };

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

@@ -0,0 +1,22 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import type { ICommandLineRewriter, ICommandLineRewriterOptions, ICommandLineRewriterResult } from "./commandLineRewriter.js";
+/**
+ * Wraps background terminal commands so their processes survive VS Code shutdown.
+ *
+ * On POSIX (bash/zsh/fish), uses `nohup <command> &` to ignore SIGHUP and
+ * detach from the terminal's process group.
+ *
+ * On Windows (PowerShell), uses `Start-Process` to create a process outside
+ * the terminal's process tree.
+ *
+ * Gated behind the {@link TerminalChatAgentToolsSettingId.DetachBackgroundProcesses} setting
+ * (default off) to avoid orphaned processes in normal usage.
+ */
+export declare class CommandLineBackgroundDetachRewriter extends Disposable implements ICommandLineRewriter {
+    private readonly _configurationService;
+    constructor(_configurationService: IConfigurationService);
+    rewrite(options: ICommandLineRewriterOptions): ICommandLineRewriterResult | undefined;
+    private _rewriteForPosix;
+    private _rewriteForPowerShell;
+}

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

@@ -0,0 +1,47 @@
+
+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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+import { isPowerShell } from '../../runInTerminalHelpers.js';
+
+let CommandLineBackgroundDetachRewriter = class CommandLineBackgroundDetachRewriter extends Disposable {
+    constructor(_configurationService) {
+        super();
+        this._configurationService = _configurationService;
+    }
+    rewrite(options) {
+        if (!options.isBackground) {
+            return undefined;
+        }
+        if (!this._configurationService.getValue(TerminalChatAgentToolsSettingId.DetachBackgroundProcesses)) {
+            return undefined;
+        }
+        if (options.os === OperatingSystem.Windows) {
+            return this._rewriteForPowerShell(options);
+        }
+        return this._rewriteForPosix(options);
+    }
+    _rewriteForPosix(options) {
+        return {
+            rewritten: `nohup ${options.commandLine} &`,
+            reasoning: "Wrapped background command with nohup to survive terminal shutdown",
+            forDisplay: options.commandLine
+        };
+    }
+    _rewriteForPowerShell(options) {
+        if (!isPowerShell(options.shell, options.os)) {
+            return undefined;
+        }
+        const escapedCommand = options.commandLine.replace(/"/g, "\\\"");
+        return {
+            rewritten: `Start-Process -WindowStyle Hidden -FilePath "${options.shell}" -ArgumentList "-NoProfile", "-Command", "${escapedCommand}"`,
+            reasoning: "Wrapped background command with Start-Process to survive terminal shutdown",
+            forDisplay: options.commandLine
+        };
+    }
+};
+CommandLineBackgroundDetachRewriter = ( __decorate([( __param(0, IConfigurationService))], CommandLineBackgroundDetachRewriter));
+
+export { CommandLineBackgroundDetachRewriter };

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

@@ -0,0 +1,5 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { ICommandLineRewriter, ICommandLineRewriterOptions, ICommandLineRewriterResult } from "./commandLineRewriter.js";
+export declare class CommandLineCdPrefixRewriter extends Disposable implements ICommandLineRewriter {
+    rewrite(options: ICommandLineRewriterOptions): ICommandLineRewriterResult | undefined;
+}

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

@@ -0,0 +1,27 @@
+
+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 { extractCdPrefix } from '../../runInTerminalHelpers.js';
+
+class CommandLineCdPrefixRewriter extends Disposable {
+    rewrite(options) {
+        if (!options.cwd) {
+            return undefined;
+        }
+        const extracted = extractCdPrefix(options.commandLine, options.shell, options.os);
+        if (extracted) {
+            let cdDirPath = extracted.directory.replace(/(?:[\\\/])$/, '');
+            let cwdFsPath = options.cwd.fsPath.replace(/(?:[\\\/])$/, '');
+            if (options.os === OperatingSystem.Windows) {
+                cdDirPath = cdDirPath.toLowerCase();
+                cwdFsPath = cwdFsPath.toLowerCase();
+            }
+            if (cdDirPath === cwdFsPath) {
+                return { rewritten: extracted.command, reasoning: 'Removed redundant cd command' };
+            }
+        }
+        return undefined;
+    }
+}
+
+export { CommandLineCdPrefixRewriter };

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

@@ -0,0 +1,14 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import type { ICommandLineRewriter, ICommandLineRewriterOptions, ICommandLineRewriterResult } from "./commandLineRewriter.js";
+/**
+ * Rewriter that prepends a space to commands to prevent them from being added to shell history for
+ * certain shells. This depends on $VSCODE_PREVENT_SHELL_HISTORY being handled in shell integration
+ * scripts to set `HISTCONTROL=ignorespace` (bash) or `HIST_IGNORE_SPACE` (zsh) env vars. The
+ * prepended space is harmless so we don't try to remove it if shell integration isn't functional.
+ */
+export declare class CommandLinePreventHistoryRewriter extends Disposable implements ICommandLineRewriter {
+    private readonly _configurationService;
+    constructor(_configurationService: IConfigurationService);
+    rewrite(options: ICommandLineRewriterOptions): ICommandLineRewriterResult | undefined;
+}

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

@@ -0,0 +1,29 @@
+
+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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { isBash, isZsh } from '../../runInTerminalHelpers.js';
+import { TerminalChatAgentToolsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration';
+
+let CommandLinePreventHistoryRewriter = class CommandLinePreventHistoryRewriter extends Disposable {
+    constructor(_configurationService) {
+        super();
+        this._configurationService = _configurationService;
+    }
+    rewrite(options) {
+        const preventShellHistory = this._configurationService.getValue(TerminalChatAgentToolsSettingId.PreventShellHistory) === true;
+        if (!preventShellHistory) {
+            return undefined;
+        }
+        if (isBash(options.shell, options.os) || isZsh(options.shell, options.os)) {
+            return {
+                rewritten: ` ${options.commandLine}`,
+                reasoning: "Prepended with a space to exclude from shell history"
+            };
+        }
+        return undefined;
+    }
+};
+CommandLinePreventHistoryRewriter = ( __decorate([( __param(0, IConfigurationService))], CommandLinePreventHistoryRewriter));
+
+export { CommandLinePreventHistoryRewriter };

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

@@ -0,0 +1,8 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import type { TreeSitterCommandParser } from "../../treeSitterCommandParser.js";
+import type { ICommandLineRewriter, ICommandLineRewriterOptions, ICommandLineRewriterResult } from "./commandLineRewriter.js";
+export declare class CommandLinePwshChainOperatorRewriter extends Disposable implements ICommandLineRewriter {
+    private readonly _treeSitterCommandParser;
+    constructor(_treeSitterCommandParser: TreeSitterCommandParser);
+    rewrite(options: ICommandLineRewriterOptions): Promise<ICommandLineRewriterResult | undefined>;
+}