@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -2,19 +2,20 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { waitForIdle, waitForIdleWithPromptHeuristics } from './executeStrategy.js';
 import { createAltBufferPromise, setupRecreatingStartMarker } from './strategyHelpers.js';
 
-let NoneExecuteStrategy = class NoneExecuteStrategy {
+let NoneExecuteStrategy = class NoneExecuteStrategy extends Disposable {
     constructor(_instance, _hasReceivedUserInput, _logService) {
+        super();
         this._instance = _instance;
         this._hasReceivedUserInput = _hasReceivedUserInput;
         this._logService = _logService;
-        this.type = 'none';
-        this._startMarker = ( new MutableDisposable());
-        this._onDidCreateStartMarker = ( new Emitter());
+        this.type = "none";
+        this._startMarker = this._register(( new MutableDisposable()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
         this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
     }
     async execute(commandLine, token, commandId) {
@@ -23,42 +24,50 @@ let NoneExecuteStrategy = class NoneExecuteStrategy {
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
-            this._log('Waiting for xterm');
+            this._log("Waiting for xterm");
             const xterm = await this._instance.xtermReadyPromise;
             if (!xterm) {
-                throw ( new Error('Xterm is not available'));
+                throw ( new Error("Xterm is not available"));
             }
             const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
-            this._log('Waiting for idle');
+            this._log("Waiting for idle");
             await waitForIdle(this._instance.onData, 1000);
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
-            setupRecreatingStartMarker(xterm, this._startMarker, m => this._onDidCreateStartMarker.fire(m), store, this._log.bind(this));
+            setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
             if (this._hasReceivedUserInput()) {
-                this._log('Command timed out, sending SIGINT and retrying');
-                await this._instance.sendText('\x03', false);
+                this._log("Command timed out, sending SIGINT and retrying");
+                await this._instance.sendText("\u0003", false);
                 await waitForIdle(this._instance.onData, 100);
             }
             this._log(`Executing command line \`${commandLine}\``);
             this._instance.sendText(commandLine, true);
-            this._log('Waiting for idle with prompt heuristics');
+            this._log("Waiting for idle with prompt heuristics");
             const promptResultOrAltBuffer = await Promise.race([
                 waitForIdleWithPromptHeuristics(this._instance.onData, this._instance, 1000, 10000),
-                alternateBufferPromise.then(() => 'alternateBuffer')
+                alternateBufferPromise.then(() => "alternateBuffer")
             ]);
-            if (promptResultOrAltBuffer === 'alternateBuffer') {
-                this._log('Detected alternate buffer entry, skipping output capture');
+            if (promptResultOrAltBuffer === "alternateBuffer") {
+                this._log("Detected alternate buffer entry, skipping output capture");
                 return {
                     output: undefined,
                     additionalInformation: undefined,
                     exitCode: undefined,
-                    error: 'alternateBuffer',
-                    didEnterAltBuffer: true,
+                    error: "alternateBuffer",
+                    didEnterAltBuffer: true
                 };
             }
             const promptResult = promptResultOrAltBuffer;
-            this._log(`Prompt detection result: ${promptResult.detected ? 'detected' : 'not detected'} - ${promptResult.reason}`);
+            this._log(
+                `Prompt detection result: ${promptResult.detected ? "detected" : "not detected"} - ${promptResult.reason}`
+            );
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
@@ -67,19 +76,17 @@ let NoneExecuteStrategy = class NoneExecuteStrategy {
             const additionalInformationLines = [];
             try {
                 output = xterm.getContentsAsText(this._startMarker.value, endMarker);
-                this._log('Fetched output via markers');
-            }
-            catch {
-                this._log('Failed to fetch output via markers');
-                additionalInformationLines.push('Failed to retrieve command output');
+                this._log("Fetched output via markers");
+            } catch {
+                this._log("Failed to fetch output via markers");
+                additionalInformationLines.push("Failed to retrieve command output");
             }
             return {
                 output,
-                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join('\n') : undefined,
-                exitCode: undefined,
+                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join("\n") : undefined,
+                exitCode: undefined
             };
-        }
-        finally {
+        } finally {
             store.dispose();
         }
     }
@@ -87,8 +94,6 @@ let NoneExecuteStrategy = class NoneExecuteStrategy {
         this._logService.debug(`RunInTerminalTool#None: ${message}`);
     }
 };
-NoneExecuteStrategy = ( __decorate([
-    ( __param(2, ITerminalLogService))
-], NoneExecuteStrategy));
+NoneExecuteStrategy = ( __decorate([( __param(2, ITerminalLogService))], NoneExecuteStrategy));
 
 export { NoneExecuteStrategy };

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

@@ -1,5 +1,6 @@
 import type { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import type { ICommandDetectionCapability } 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";
 import type { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
@@ -12,7 +13,7 @@ import type { IMarker as IXtermMarker } from "@xterm/xterm";
  * wrong in this state, minimal verification is done in this mode since rich command detection is a
  * strong signal that it's behaving correctly.
  */
-export declare class RichExecuteStrategy implements ITerminalExecuteStrategy {
+export declare class RichExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
     private readonly _instance;
     private readonly _commandDetection;
     private readonly _logService;

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

@@ -2,68 +2,79 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { isNumber } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { ITerminalLogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal.service';
 import { trackIdleOnPrompt } from './executeStrategy.js';
 import { createAltBufferPromise, setupRecreatingStartMarker } from './strategyHelpers.js';
 
-let RichExecuteStrategy = class RichExecuteStrategy {
+let RichExecuteStrategy = class RichExecuteStrategy extends Disposable {
     constructor(_instance, _commandDetection, _logService) {
+        super();
         this._instance = _instance;
         this._commandDetection = _commandDetection;
         this._logService = _logService;
-        this.type = 'rich';
-        this._startMarker = ( new MutableDisposable());
-        this._onDidCreateStartMarker = ( new Emitter());
+        this.type = "rich";
+        this._startMarker = this._register(( new MutableDisposable()));
+        this._onDidCreateStartMarker = this._register(( new Emitter()));
         this.onDidCreateStartMarker = this._onDidCreateStartMarker.event;
     }
     async execute(commandLine, token, commandId) {
         const store = ( new DisposableStore());
         try {
-            this._log('Waiting for xterm');
+            this._log("Waiting for xterm");
             const xterm = await this._instance.xtermReadyPromise;
             if (!xterm) {
-                throw ( new Error('Xterm is not available'));
+                throw ( new Error("Xterm is not available"));
             }
             const alternateBufferPromise = createAltBufferPromise(xterm, store, this._log.bind(this));
             const onDone = Promise.race([
                 Event.toPromise(this._commandDetection.onCommandFinished, store).then(e => {
-                    this._log('onDone via end event');
+                    this._log("onDone via end event");
                     return {
-                        'type': 'success',
+                        "type": "success",
                         command: e
                     };
                 }),
                 Event.toPromise(token.onCancellationRequested, store).then(() => {
-                    this._log('onDone via cancellation');
+                    this._log("onDone via cancellation");
                 }),
                 Event.toPromise(this._instance.onDisposed, store).then(() => {
-                    this._log('onDone via terminal disposal');
-                    return { type: 'disposal' };
+                    this._log("onDone via terminal disposal");
+                    return {
+                        type: "disposal"
+                    };
                 }),
                 trackIdleOnPrompt(this._instance, 1000, store).then(() => {
-                    this._log('onDone via idle prompt');
-                }),
+                    this._log("onDone via idle prompt");
+                })
             ]);
-            setupRecreatingStartMarker(xterm, this._startMarker, m => this._onDidCreateStartMarker.fire(m), store, this._log.bind(this));
+            setupRecreatingStartMarker(
+                xterm,
+                this._startMarker,
+                m => this._onDidCreateStartMarker.fire(m),
+                store,
+                this._log.bind(this)
+            );
             this._log(`Executing command line \`${commandLine}\``);
             this._instance.runCommand(commandLine, true, commandId);
-            this._log('Waiting for done event');
-            const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({ type: 'alternateBuffer' }))]);
-            if (onDoneResult && onDoneResult.type === 'disposal') {
-                throw ( new Error('The terminal was closed'));
+            this._log("Waiting for done event");
+            const onDoneResult = await Promise.race([onDone, alternateBufferPromise.then(() => ({
+                type: "alternateBuffer"
+            }))]);
+            if (onDoneResult && onDoneResult.type === "disposal") {
+                throw ( new Error("The terminal was closed"));
             }
-            if (onDoneResult && onDoneResult.type === 'alternateBuffer') {
-                this._log('Detected alternate buffer entry, skipping output capture');
+            if (onDoneResult && onDoneResult.type === "alternateBuffer") {
+                this._log("Detected alternate buffer entry, skipping output capture");
                 return {
                     output: undefined,
                     exitCode: undefined,
-                    error: 'alternateBuffer',
+                    error: "alternateBuffer",
                     didEnterAltBuffer: true
                 };
             }
-            const finishedCommand = onDoneResult && onDoneResult.type === 'success' ? onDoneResult.command : undefined;
+            const finishedCommand = onDoneResult && onDoneResult.type === "success" ? onDoneResult.command : undefined;
             if (token.isCancellationRequested) {
                 throw ( new CancellationError());
             }
@@ -73,22 +84,21 @@ let RichExecuteStrategy = class RichExecuteStrategy {
             if (finishedCommand) {
                 const commandOutput = finishedCommand?.getOutput();
                 if (commandOutput !== undefined) {
-                    this._log('Fetched output via finished command');
+                    this._log("Fetched output via finished command");
                     output = commandOutput;
                 }
             }
             if (output === undefined) {
                 try {
                     output = xterm.getContentsAsText(this._startMarker.value, endMarker);
-                    this._log('Fetched output via markers');
-                }
-                catch {
-                    this._log('Failed to fetch output via markers');
-                    additionalInformationLines.push('Failed to retrieve command output');
+                    this._log("Fetched output via markers");
+                } catch {
+                    this._log("Failed to fetch output via markers");
+                    additionalInformationLines.push("Failed to retrieve command output");
                 }
             }
             if (output !== undefined && output.trim().length === 0) {
-                additionalInformationLines.push('Command produced no output');
+                additionalInformationLines.push("Command produced no output");
             }
             const exitCode = finishedCommand?.exitCode;
             if (isNumber(exitCode) && exitCode > 0) {
@@ -96,11 +106,10 @@ let RichExecuteStrategy = class RichExecuteStrategy {
             }
             return {
                 output,
-                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join('\n') : undefined,
-                exitCode,
+                additionalInformation: additionalInformationLines.length > 0 ? additionalInformationLines.join("\n") : undefined,
+                exitCode
             };
-        }
-        finally {
+        } finally {
             store.dispose();
         }
     }
@@ -108,8 +117,6 @@ let RichExecuteStrategy = class RichExecuteStrategy {
         this._logService.debug(`RunInTerminalTool#Rich: ${message}`);
     }
 };
-RichExecuteStrategy = ( __decorate([
-    ( __param(2, ITerminalLogService))
-], RichExecuteStrategy));
+RichExecuteStrategy = ( __decorate([( __param(2, ITerminalLogService))], RichExecuteStrategy));
 
 export { RichExecuteStrategy };

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

@@ -16,7 +16,7 @@ function setupRecreatingStartMarker(xterm, startMarker, fire, store, log) {
             return;
         }
         markerListener.value = marker.onDispose(() => {
-            log?.('Start marker was disposed, recreating');
+            log?.("Start marker was disposed, recreating");
             recreateStartMarker();
         });
     };
@@ -32,14 +32,13 @@ function createAltBufferPromise(xterm, store, log) {
     const deferred = ( new DeferredPromise());
     const complete = () => {
         if (!deferred.isSettled) {
-            log?.('Detected alternate buffer entry');
+            log?.("Detected alternate buffer entry");
             deferred.complete();
         }
     };
     if (xterm.raw.buffer.active === xterm.raw.buffer.alternate) {
         complete();
-    }
-    else {
+    } else {
         store.add(xterm.raw.buffer.onBufferChange(() => {
             if (xterm.raw.buffer.active === xterm.raw.buffer.alternate) {
                 complete();

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

@@ -4,7 +4,7 @@ import { truncateOutputKeepingTail } from './runInTerminalHelpers.js';
 const MAX_OUTPUT_LENGTH = 16000;
 function getOutput(instance, startMarker) {
     if (!instance.xterm || !instance.xterm.raw) {
-        return '';
+        return "";
     }
     const buffer = instance.xterm.raw.buffer.active;
     const startLine = Math.max(startMarker?.line ?? 0, 0);
@@ -12,9 +12,9 @@ function getOutput(instance, startMarker) {
     const lines = ( new Array(endLine - startLine));
     for (let y = startLine; y < endLine; y++) {
         const line = buffer.getLine(y);
-        lines[y - startLine] = line ? line.translateToString(true) : '';
+        lines[y - startLine] = line ? line.translateToString(true) : "";
     }
-    let output = lines.join('\n');
+    let output = lines.join("\n");
     if (output.length > MAX_OUTPUT_LENGTH) {
         output = truncateOutputKeepingTail(output, MAX_OUTPUT_LENGTH);
     }

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

@@ -14,3 +14,14 @@ export declare function generateAutoApproveActions(commandLine: string, subComma
     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

@@ -9,12 +9,12 @@ import { isAutoApproveRule } from './tools/commandLineAnalyzer/commandLineAnalyz
 
 function isPowerShell(envShell, os) {
     if (os === OperatingSystem.Windows) {
-        return /^(?:powershell|pwsh)(?:-preview)?$/i.test(win32.basename(envShell).replace(/\.exe$/i, ''));
+        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');
+    return envShell.endsWith("System32\\WindowsPowerShell\\v1.0\\powershell.exe");
 }
 function isZsh(envShell, os) {
     if (os === OperatingSystem.Windows) {
@@ -34,7 +34,7 @@ function isFish(envShell, os) {
     }
     return /^fish$/.test(posix.basename(envShell));
 }
-const TRUNCATION_MESSAGE = '\n\n[... PREVIOUS OUTPUT TRUNCATED ...]\n\n';
+const TRUNCATION_MESSAGE = "\n\n[... PREVIOUS OUTPUT TRUNCATED ...]\n\n";
 function truncateOutputKeepingTail(output, maxLength) {
     if (output.length <= maxLength) {
         return output;
@@ -49,26 +49,32 @@ function truncateOutputKeepingTail(output, maxLength) {
 }
 function generateAutoApproveActions(commandLine, subCommands, autoApproveResult) {
     const actions = [];
-    const canCreateAutoApproval = (autoApproveResult.subCommandResults.every(e => e.result !== 'denied') &&
-        autoApproveResult.commandLineResult.result !== 'denied');
+    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';
+            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',
+        "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 commandsWithSubcommands = ( new Set(
-            ['git', 'npm', 'npx', 'yarn', 'docker', 'kubectl', 'cargo', 'dotnet', 'mvn', 'gradle']
-        ));
-        const commandsWithSubSubCommands = ( new Set(['npm run', 'yarn run']));
+        const commandsWithSubSubCommands = ( new Set(["npm run", "yarn run"]));
         const findNextNonFlagArg = (parts, startIndex) => {
             for (let i = startIndex; i < parts.length; i++) {
-                if (!parts[i].startsWith('-')) {
+                if (!parts[i].startsWith("-")) {
                     return i;
                 }
             }
@@ -87,17 +93,15 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
                     if (( commandsWithSubSubCommands.has(baseSubCommand))) {
                         const subSubCommandIndex = findNextNonFlagArg(parts, subCommandIndex + 1);
                         if (subSubCommandIndex !== undefined) {
-                            return parts.slice(0, subSubCommandIndex + 1).join(' ');
+                            return parts.slice(0, subSubCommandIndex + 1).join(" ");
                         }
                         return undefined;
-                    }
-                    else {
-                        return parts.slice(0, subCommandIndex + 1).join(' ');
+                    } else {
+                        return parts.slice(0, subCommandIndex + 1).join(" ");
                     }
                 }
                 return undefined;
-            }
-            else {
+            } else {
                 return parts[0];
             }
         }))))));
@@ -105,40 +109,39 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
             let subCommandLabel;
             if (subCommandsToSuggest.length === 1) {
                 subCommandLabel = `\`${subCommandsToSuggest[0]} \u2026\``;
-            }
-            else {
-                subCommandLabel = `Commands ${( subCommandsToSuggest.map(e => `\`${e} \u2026\``)).join(', ')}`;
+            } else {
+                subCommandLabel = `Commands ${( subCommandsToSuggest.map(e => `\`${e} \u2026\``)).join(", ")}`;
             }
             actions.push({
                 label: `Allow ${subCommandLabel} in this Session`,
                 data: {
-                    type: 'newRule',
+                    type: "newRule",
                     rule: ( subCommandsToSuggest.map(key => ({
                         key,
                         value: true,
-                        scope: 'session'
+                        scope: "session"
                     })))
                 }
             });
             actions.push({
                 label: `Allow ${subCommandLabel} in this Workspace`,
                 data: {
-                    type: 'newRule',
+                    type: "newRule",
                     rule: ( subCommandsToSuggest.map(key => ({
                         key,
                         value: true,
-                        scope: 'workspace'
+                        scope: "workspace"
                     })))
                 }
             });
             actions.push({
                 label: `Always Allow ${subCommandLabel}`,
                 data: {
-                    type: 'newRule',
+                    type: "newRule",
                     rule: ( subCommandsToSuggest.map(key => ({
                         key,
                         value: true,
-                        scope: 'user'
+                        scope: "user"
                     })))
                 }
             });
@@ -146,49 +149,47 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
         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))) {
+        const firstSubcommandFirstWord = unapprovedSubCommands.length > 0 ? unapprovedSubCommands[0].split(" ")[0] : "";
+        if (firstSubcommandFirstWord !== commandLine && !( commandsWithSubcommands.has(commandLine)) && !( commandsWithSubSubCommands.has(commandLine))) {
             actions.push({
-                label: ( localize(12014, 'Allow Exact Command Line in this Session')),
+                label: ( localize(12342, "Allow Exact Command Line in this Session")),
                 data: {
-                    type: 'newRule',
+                    type: "newRule",
                     rule: {
                         key: `/^${escapeRegExpCharacters(commandLine)}$/`,
                         value: {
                             approve: true,
                             matchCommandLine: true
                         },
-                        scope: 'session'
+                        scope: "session"
                     }
                 }
             });
             actions.push({
-                label: ( localize(12015, 'Allow Exact Command Line in this Workspace')),
+                label: ( localize(12343, "Allow Exact Command Line in this Workspace")),
                 data: {
-                    type: 'newRule',
+                    type: "newRule",
                     rule: {
                         key: `/^${escapeRegExpCharacters(commandLine)}$/`,
                         value: {
                             approve: true,
                             matchCommandLine: true
                         },
-                        scope: 'workspace'
+                        scope: "workspace"
                     }
                 }
             });
             actions.push({
-                label: ( localize(12016, 'Always Allow Exact Command Line')),
+                label: ( localize(12344, "Always Allow Exact Command Line")),
                 data: {
-                    type: 'newRule',
+                    type: "newRule",
                     rule: {
                         key: `/^${escapeRegExpCharacters(commandLine)}$/`,
                         value: {
                             approve: true,
                             matchCommandLine: true
                         },
-                        scope: 'user'
+                        scope: "user"
                     }
                 }
             });
@@ -198,17 +199,17 @@ function generateAutoApproveActions(commandLine, subCommands, autoApproveResult)
         actions.push(( new Separator()));
     }
     actions.push({
-        label: ( localize(12017, 'Allow All Commands in this Session')),
-        tooltip: ( localize(12018, 'Allow this tool to run in this session without confirmation.')),
+        label: ( localize(12345, "Allow All Commands in this Session")),
+        tooltip: ( localize(12346, "Allow this tool to run in this session without confirmation.")),
         data: {
-            type: 'sessionApproval'
+            type: "sessionApproval"
         }
     });
     actions.push(( new Separator()));
     actions.push({
-        label: ( localize(12019, 'Configure Auto Approve...')),
+        label: ( localize(12347, "Configure Auto Approve...")),
         data: {
-            type: 'configure'
+            type: "configure"
         }
     });
     return actions;
@@ -222,5 +223,24 @@ function dedupeRules(rules) {
         return array.findIndex(r => isAutoApproveRule(r.rule) && r.rule.sourceText === sourceText) === index;
     });
 }
+function extractCdPrefix(commandLine, shell, os) {
+    const isPwsh = isPowerShell(shell, os);
+    const cdPrefixMatch = commandLine.match(
+        isPwsh ? /^(?:cd(?: \/d)?|Set-Location(?: -Path)?) (?<dir>[^\s]+) ?(?:&&|;)\s+(?<suffix>.+)$/i : /^cd (?<dir>[^\s]+) &&\s+(?<suffix>.+)$/
+    );
+    const cdDir = cdPrefixMatch?.groups?.dir;
+    const cdSuffix = cdPrefixMatch?.groups?.suffix;
+    if (cdDir && cdSuffix) {
+        let cdDirPath = cdDir;
+        if (cdDirPath.startsWith("\"") && cdDirPath.endsWith("\"")) {
+            cdDirPath = cdDirPath.slice(1, -1);
+        }
+        return {
+            directory: cdDirPath,
+            command: cdSuffix
+        };
+    }
+    return undefined;
+}
 
-export { TRUNCATION_MESSAGE, dedupeRules, generateAutoApproveActions, isBash, isFish, isPowerShell, isWindowsPowerShell, isZsh, truncateOutputKeepingTail };
+export { TRUNCATION_MESSAGE, dedupeRules, extractCdPrefix, generateAutoApproveActions, isBash, isFish, isPowerShell, isWindowsPowerShell, isZsh, truncateOutputKeepingTail };