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

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/notebookFindWidget.js

@@ -348,9 +348,9 @@ let NotebookFindWidget = class NotebookFindWidget extends SimpleFindReplaceWidge
     }
     _getAriaLabel(label, currentMatch, searchString) {
         if (label === NLS_NO_RESULTS) {
-            return searchString === "" ? ( localize(11026, "{0} found", label)) : ( localize(11027, "{0} found for '{1}'", label, searchString));
+            return searchString === "" ? ( localize(11158, "{0} found", label)) : ( localize(11159, "{0} found for '{1}'", label, searchString));
         }
-        return localize(11028, "{0} found for '{1}'", label, searchString);
+        return localize(11160, "{0} found for '{1}'", label, searchString);
     }
     dispose() {
         this._notebookEditor?.removeClassName(FIND_SHOW_TRANSITION);

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/cellOperations.js

@@ -402,7 +402,7 @@ async function joinSelectedCells(bulkEditService, notificationService, context)
     const cellKind = cells[0].cellKind;
     const isSameKind = cells.every(cell => cell.cellKind === cellKind);
     if (!isSameKind) {
-        const message = ( localize(11084, "Cannot join cells of different kinds"));
+        const message = ( localize(11216, "Cannot join cells of different kinds"));
         return notificationService.warn(message);
     }
     const firstCell = cells[0];
@@ -431,7 +431,7 @@ async function joinSelectedCells(bulkEditService, notificationService, context)
     }
     if (edits.length) {
         await bulkEditService.apply(edits, {
-            quotableLabel: ( localize(11085, "Join Notebook Cells"))
+            quotableLabel: ( localize(11217, "Join Notebook Cells"))
         });
     }
 }

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/insertCellActions.js

@@ -74,7 +74,7 @@ registerAction2(class InsertCodeCellAboveAction extends InsertCellCommand {
     constructor() {
         super({
             id: INSERT_CODE_CELL_ABOVE_COMMAND_ID,
-            title: ( localize(11151, "Insert Code Cell Above")),
+            title: ( localize(11283, "Insert Code Cell Above")),
             keybinding: {
                 primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Enter,
                 when: ( ContextKeyExpr.and(NOTEBOOK_CELL_LIST_FOCUSED, ( InputFocusedContext.toNegated()))),
@@ -92,7 +92,7 @@ registerAction2(
         constructor() {
             super({
                 id: INSERT_CODE_CELL_ABOVE_AND_FOCUS_CONTAINER_COMMAND_ID,
-                title: ( localize(11152, "Insert Code Cell Above and Focus Container"))
+                title: ( localize(11284, "Insert Code Cell Above and Focus Container"))
             }, CellKind.Code, "above", false);
         }
     }
@@ -101,7 +101,7 @@ registerAction2(class InsertCodeCellBelowAction extends InsertCellCommand {
     constructor() {
         super({
             id: INSERT_CODE_CELL_BELOW_COMMAND_ID,
-            title: ( localize(11153, "Insert Code Cell Below")),
+            title: ( localize(11285, "Insert Code Cell Below")),
             keybinding: {
                 primary: KeyMod.CtrlCmd | KeyCode.Enter,
                 when: ( ContextKeyExpr.and(NOTEBOOK_CELL_LIST_FOCUSED, ( InputFocusedContext.toNegated()))),
@@ -119,7 +119,7 @@ registerAction2(
         constructor() {
             super({
                 id: INSERT_CODE_CELL_BELOW_AND_FOCUS_CONTAINER_COMMAND_ID,
-                title: ( localize(11154, "Insert Code Cell Below and Focus Container"))
+                title: ( localize(11286, "Insert Code Cell Below and Focus Container"))
             }, CellKind.Code, "below", false);
         }
     }
@@ -128,7 +128,7 @@ registerAction2(class InsertMarkdownCellAboveAction extends InsertCellCommand {
     constructor() {
         super({
             id: INSERT_MARKDOWN_CELL_ABOVE_COMMAND_ID,
-            title: ( localize(11155, "Insert Markdown Cell Above")),
+            title: ( localize(11287, "Insert Markdown Cell Above")),
             menu: {
                 id: MenuId.NotebookCellInsert,
                 order: 2
@@ -140,7 +140,7 @@ registerAction2(class InsertMarkdownCellBelowAction extends InsertCellCommand {
     constructor() {
         super({
             id: INSERT_MARKDOWN_CELL_BELOW_COMMAND_ID,
-            title: ( localize(11156, "Insert Markdown Cell Below")),
+            title: ( localize(11288, "Insert Markdown Cell Below")),
             menu: {
                 id: MenuId.NotebookCellInsert,
                 order: 3
@@ -152,7 +152,7 @@ registerAction2(class InsertCodeCellAtTopAction extends NotebookAction {
     constructor() {
         super({
             id: INSERT_CODE_CELL_AT_TOP_COMMAND_ID,
-            title: ( localize(11157, "Add Code Cell At Top")),
+            title: ( localize(11289, "Add Code Cell At Top")),
             f1: false
         });
     }
@@ -184,7 +184,7 @@ registerAction2(class InsertMarkdownCellAtTopAction extends NotebookAction {
     constructor() {
         super({
             id: INSERT_MARKDOWN_CELL_AT_TOP_COMMAND_ID,
-            title: ( localize(11158, "Add Markdown Cell At Top")),
+            title: ( localize(11290, "Add Markdown Cell At Top")),
             f1: false
         });
     }
@@ -215,8 +215,8 @@ registerAction2(class InsertMarkdownCellAtTopAction extends NotebookAction {
 MenuRegistry.appendMenuItem(MenuId.NotebookCellBetween, {
     command: {
         id: INSERT_CODE_CELL_BELOW_COMMAND_ID,
-        title: "$(add) " + ( localize(11159, "Code")),
-        tooltip: ( localize(11160, "Add Code Cell"))
+        title: "$(add) " + ( localize(11291, "Code")),
+        tooltip: ( localize(11292, "Add Code Cell"))
     },
     order: 0,
     group: "inline",
@@ -225,9 +225,9 @@ MenuRegistry.appendMenuItem(MenuId.NotebookCellBetween, {
 MenuRegistry.appendMenuItem(MenuId.NotebookCellBetween, {
     command: {
         id: INSERT_CODE_CELL_BELOW_COMMAND_ID,
-        title: ( localize(11161, "Add Code")),
+        title: ( localize(11293, "Add Code")),
         icon: Codicon.add,
-        tooltip: ( localize(11160, "Add Code Cell"))
+        tooltip: ( localize(11292, "Add Code Cell"))
     },
     order: 0,
     group: "inline",
@@ -237,8 +237,8 @@ MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
     command: {
         id: INSERT_CODE_CELL_BELOW_COMMAND_ID,
         icon: Codicon.add,
-        title: ( localize(11162, "Code")),
-        tooltip: ( localize(11160, "Add Code Cell"))
+        title: ( localize(11294, "Code")),
+        tooltip: ( localize(11292, "Add Code Cell"))
     },
     order: -5,
     group: "navigation/add",
@@ -247,8 +247,8 @@ MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
 MenuRegistry.appendMenuItem(MenuId.NotebookCellListTop, {
     command: {
         id: INSERT_CODE_CELL_AT_TOP_COMMAND_ID,
-        title: "$(add) " + ( localize(11159, "Code")),
-        tooltip: ( localize(11160, "Add Code Cell"))
+        title: "$(add) " + ( localize(11291, "Code")),
+        tooltip: ( localize(11292, "Add Code Cell"))
     },
     order: 0,
     group: "inline",
@@ -257,9 +257,9 @@ MenuRegistry.appendMenuItem(MenuId.NotebookCellListTop, {
 MenuRegistry.appendMenuItem(MenuId.NotebookCellListTop, {
     command: {
         id: INSERT_CODE_CELL_AT_TOP_COMMAND_ID,
-        title: ( localize(11163, "Add Code")),
+        title: ( localize(11295, "Add Code")),
         icon: Codicon.add,
-        tooltip: ( localize(11160, "Add Code Cell"))
+        tooltip: ( localize(11292, "Add Code Cell"))
     },
     order: 0,
     group: "inline",
@@ -268,8 +268,8 @@ MenuRegistry.appendMenuItem(MenuId.NotebookCellListTop, {
 MenuRegistry.appendMenuItem(MenuId.NotebookCellBetween, {
     command: {
         id: INSERT_MARKDOWN_CELL_BELOW_COMMAND_ID,
-        title: "$(add) " + ( localize(11164, "Markdown")),
-        tooltip: ( localize(11165, "Add Markdown Cell"))
+        title: "$(add) " + ( localize(11296, "Markdown")),
+        tooltip: ( localize(11297, "Add Markdown Cell"))
     },
     order: 1,
     group: "inline",
@@ -279,8 +279,8 @@ MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
     command: {
         id: INSERT_MARKDOWN_CELL_BELOW_COMMAND_ID,
         icon: Codicon.add,
-        title: ( localize(11166, "Markdown")),
-        tooltip: ( localize(11165, "Add Markdown Cell"))
+        title: ( localize(11298, "Markdown")),
+        tooltip: ( localize(11297, "Add Markdown Cell"))
     },
     order: -5,
     group: "navigation/add",
@@ -289,8 +289,8 @@ MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
 MenuRegistry.appendMenuItem(MenuId.NotebookCellListTop, {
     command: {
         id: INSERT_MARKDOWN_CELL_AT_TOP_COMMAND_ID,
-        title: "$(add) " + ( localize(11164, "Markdown")),
-        tooltip: ( localize(11165, "Add Markdown Cell"))
+        title: "$(add) " + ( localize(11296, "Markdown")),
+        tooltip: ( localize(11297, "Add Markdown Cell"))
     },
     order: 1,
     group: "inline",

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffComponents.js

@@ -61,7 +61,7 @@ class CellDiffPlaceholderElement extends Disposable {
     constructor(placeholder, templateData) {
         super();
         templateData.body.classList.remove("left", "right", "full");
-        const text = (placeholder.hiddenCells.length === 1) ? ( localize(11202, "{0} hidden cell", placeholder.hiddenCells.length)) : ( localize(11203, "{0} hidden cells", placeholder.hiddenCells.length));
+        const text = (placeholder.hiddenCells.length === 1) ? ( localize(11334, "{0} hidden cell", placeholder.hiddenCells.length)) : ( localize(11335, "{0} hidden cells", placeholder.hiddenCells.length));
         templateData.placeholder.innerText = text;
         this._register(addDisposableListener(templateData.placeholder, "dblclick", e => {
             if (e.button !== 0) {
@@ -1902,7 +1902,7 @@ class CollapsedCellOverlayWidget extends Disposable {
                 display: "flex"
             }
         }, [$("a", {
-            title: ( localize(11204, "Show Unchanged Cells")),
+            title: ( localize(11336, "Show Unchanged Cells")),
             role: "button",
             onclick: () => {
                 this._action.fire();
@@ -1935,7 +1935,7 @@ class UnchangedCellOverlayWidget extends Disposable {
                 display: "flex"
             }
         }, [$("a", {
-            title: ( localize(11205, "Hide Unchanged Cells")),
+            title: ( localize(11337, "Hide Unchanged Cells")),
             role: "button",
             onclick: () => {
                 this._action.fire();

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffElementOutputs.js

@@ -48,7 +48,7 @@ class OutputElement extends Disposable {
             mimeTypePicker.classList.add(...ThemeIcon.asClassNameArray(mimetypeIcon));
             mimeTypePicker.tabIndex = 0;
             mimeTypePicker.title = ( localize(
-                11206,
+                11338,
                 "Choose a different output mimetype, available mimetypes: {0}",
                 ( mimeTypes.map(mimeType => mimeType.mimeType)).join(", ")
             ));
@@ -105,13 +105,13 @@ class OutputElement extends Disposable {
     }
     _renderMissingRenderer(viewModel, preferredMimeType) {
         if (!viewModel.model.outputs.length) {
-            return this._renderMessage(viewModel, ( localize(11207, "Cell has no output")));
+            return this._renderMessage(viewModel, ( localize(11339, "Cell has no output")));
         }
         if (!preferredMimeType) {
             const mimeTypes = ( viewModel.model.outputs.map(op => op.mime));
             const mimeTypesMessage = mimeTypes.join(", ");
             return this._renderMessage(viewModel, ( localize(
-                11208,
+                11340,
                 "No renderer could be found for output. It has the following mimetypes: {0}",
                 mimeTypesMessage
             )));
@@ -154,16 +154,16 @@ class OutputElement extends Disposable {
             index: index,
             picked: index === currIndex,
             detail: this.generateRendererInfo(mimeType.rendererId),
-            description: index === currIndex ? ( localize(11209, "Currently Active")) : undefined
+            description: index === currIndex ? ( localize(11341, "Currently Active")) : undefined
         })));
         const disposables = ( new DisposableStore());
         const picker = disposables.add(this._quickInputService.createQuickPick());
         picker.items = items;
         picker.activeItems = items.filter(item => !!item.picked);
         picker.placeholder = items.length !== mimeTypes.length ? ( localize(
-            11210,
+            11342,
             "Select mimetype to render for current output. Rich mimetypes are available only when the notebook is trusted"
-        )) : ( localize(11211, "Select mimetype to render for current output"));
+        )) : ( localize(11343, "Select mimetype to render for current output"));
         const pick = await ( new Promise(resolve => {
             disposables.add(picker.onDidAccept(() => {
                 resolve(
@@ -195,7 +195,7 @@ class OutputElement extends Disposable {
             const displayName = renderInfo.displayName !== "" ? renderInfo.displayName : renderInfo.id;
             return `${displayName} (${renderInfo.extensionId.value})`;
         }
-        return localize(11212, "built-in");
+        return localize(11344, "built-in");
     }
     getCellOutputCurrentIndex() {
         return this._diffElementViewModel.getNestedCellViewModel(this._diffSide).outputs.indexOf(this.output.model);

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor.js

@@ -316,7 +316,7 @@ let NotebookTextDiffEditor = class NotebookTextDiffEditor extends EditorPane {
                         return null;
                     },
                     getWidgetAriaLabel() {
-                        return localize(11233, "Notebook Text Diff");
+                        return localize(11365, "Notebook Text Diff");
                     }
                 }
             }

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditorBrowser.js

@@ -14,18 +14,18 @@ const NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY = "notebook.diffEditor.cell.ignor
 const NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE = ( new RawContextKey(NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY, false));
 const NOTEBOOK_DIFF_CELL_PROPERTY = ( new RawContextKey("notebook.diffEditor.cell.property.changed", false));
 const NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED = ( new RawContextKey("notebook.diffEditor.cell.property.expanded", false));
-const NOTEBOOK_DIFF_CELLS_COLLAPSED = ( new RawContextKey("notebook.diffEditor.allCollapsed", undefined, ( localize(11234, "Whether all cells in notebook diff editor are collapsed"))));
-const NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS = ( new RawContextKey("notebook.diffEditor.hasUnchangedCells", undefined, ( localize(11235, "Whether there are unchanged cells in the notebook diff editor"))));
+const NOTEBOOK_DIFF_CELLS_COLLAPSED = ( new RawContextKey("notebook.diffEditor.allCollapsed", undefined, ( localize(11366, "Whether all cells in notebook diff editor are collapsed"))));
+const NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS = ( new RawContextKey("notebook.diffEditor.hasUnchangedCells", undefined, ( localize(11367, "Whether there are unchanged cells in the notebook diff editor"))));
 const NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN = ( new RawContextKey("notebook.diffEditor.unchangedCellsAreHidden", undefined, ( localize(
-    11236,
+    11368,
     "Whether the unchanged cells in the notebook diff editor are hidden"
 ))));
 const NOTEBOOK_DIFF_ITEM_KIND = ( new RawContextKey("notebook.diffEditor.item.kind", undefined, ( localize(
-    11237,
+    11369,
     "The kind of item in the notebook diff editor, Cell, Metadata or Output"
 ))));
 const NOTEBOOK_DIFF_ITEM_DIFF_STATE = ( new RawContextKey("notebook.diffEditor.item.state", undefined, ( localize(
-    11238,
+    11370,
     "The diff state of item in the notebook diff editor, delete, insert, modified or unchanged"
 ))));
 

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookDiffList.js

@@ -82,7 +82,7 @@ let CellDiffPlaceholderRenderer = class CellDiffPlaceholderRenderer {
         const marginOverlay = ( new CollapsedCellOverlayWidget(body));
         const contents = append(body, $(".contents"));
         const placeholder = append(contents, $("span.text", {
-            title: ( localize(11239, "Double click to show"))
+            title: ( localize(11371, "Double click to show"))
         }));
         return {
             body,

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditor.js

@@ -243,7 +243,7 @@ let ReplEditor = class ReplEditor extends EditorPane {
             ...editorOptions,
             ...editorOptionsOverride,
             ...{
-                ariaLabel: ( localize(12192, "REPL Input")),
+                ariaLabel: ( localize(12326, "REPL Input")),
                 glyphMargin: true,
                 padding: {
                     top: INPUT_EDITOR_PADDING,

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditorInput.js

@@ -23,7 +23,7 @@ import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscod
 import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
 
 var ReplEditorInput_1;
-const replTabIcon = registerIcon("repl-editor-label-icon", Codicon.debugLineByLine, ( localize(12206, "Icon of the REPL editor label.")));
+const replTabIcon = registerIcon("repl-editor-label-icon", Codicon.debugLineByLine, ( localize(12340, "Icon of the REPL editor label.")));
 let ReplEditorInput = class ReplEditorInput extends NotebookEditorInput {
     static {
         ReplEditorInput_1 = this;

package/vscode/src/vs/workbench/contrib/terminal/terminalContribChatExports.d.ts

@@ -0,0 +1,2 @@
+export { MENU_CHAT_TERMINAL_TOOL_PROGRESS, TerminalChatContextKeys } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminalContrib/chat/browser/terminalChat";
+export { RunInTerminalTool } from "../terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.js";

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

@@ -0,0 +1,2 @@
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+export declare function getRecommendedToolsOverRunInTerminal(commandLine: string, languageModelToolsService: ILanguageModelToolsService): string | undefined;

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

@@ -0,0 +1,41 @@
+
+
+let previouslyRecommededInSession = false;
+const terminalCommands = [{
+    commands: [( new RegExp(/^python3? -m pip install(\b)/)), ( new RegExp(/^pip3? install(\b)/))],
+    tags: ["python environment"]
+}, {
+    commands: [( new RegExp(/^python3? -m jupyter(\b)/)), ( new RegExp(/^python3? -m pip install\b.*jupyter\b.*/)), ( new RegExp(/^pip3? install\b.*jupyter\b.*/)), (
+    new RegExp(/^jupyter(\b)/))],
+    tags: ["python environment", "jupyter environment"]
+}];
+function getRecommendedToolsOverRunInTerminal(commandLine, languageModelToolsService) {
+    const tools = languageModelToolsService.getTools(undefined);
+    if (!tools || previouslyRecommededInSession) {
+        return;
+    }
+    const recommendedTools = ( new Set());
+    const messages = [
+        `The terminal command '${commandLine}' was not executed.`,
+        `Try using some of the following tools instead of running a Terminal Command (if unable to use one of these tools as an alternative then run the same terminal command again):`
+    ];
+    for (const terminalCommand of terminalCommands) {
+        if (!( terminalCommand.commands.some(condition => condition.test(commandLine)))) {
+            continue;
+        }
+        const tagsToSearchFor = terminalCommand.tags;
+        Array.from(tools).filter(t => ( tagsToSearchFor.some(tag => t.tags?.includes(tag)))).forEach(tool => {
+            recommendedTools.add(tool.id);
+        });
+    }
+    recommendedTools.forEach(toolName => {
+        messages.push(`- ${toolName}`);
+    });
+    if (recommendedTools.size) {
+        previouslyRecommededInSession = true;
+        return messages.join("  \n");
+    }
+    return undefined;
+}
+
+export { getRecommendedToolsOverRunInTerminal };

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

@@ -0,0 +1,24 @@
+/**
+ * Interface for command-specific file write parsers.
+ * Each parser is responsible for detecting when a specific command will write to files
+ * (beyond simple shell redirections which are handled separately via tree-sitter queries).
+ */
+export interface ICommandFileWriteParser {
+    /**
+     * The name of the command this parser handles (e.g., 'sed', 'tee').
+     */
+    readonly commandName: string;
+    /**
+     * Checks if this parser can handle the given command text.
+     * Should return true only if the command would write to files.
+     * @param commandText The full text of a single command (not a pipeline).
+     */
+    canHandle(commandText: string): boolean;
+    /**
+     * Extracts the file paths that would be written to by this command.
+     * Should only be called if canHandle() returns true.
+     * @param commandText The full text of a single command (not a pipeline).
+     * @returns Array of file paths that would be modified.
+     */
+    extractFileWrites(commandText: string): string[];
+}

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

@@ -0,0 +1,26 @@
+import { ICommandFileWriteParser } from "./commandFileWriteParser.js";
+/**
+ * Parser for detecting file writes from `sed` commands using in-place editing.
+ *
+ * Handles:
+ * - `sed -i 's/foo/bar/' file.txt` (GNU)
+ * - `sed -i.bak 's/foo/bar/' file.txt` (GNU with backup suffix)
+ * - `sed -i '' 's/foo/bar/' file.txt` (macOS/BSD with empty backup suffix)
+ * - `sed --in-place 's/foo/bar/' file.txt` (GNU long form)
+ * - `sed --in-place=.bak 's/foo/bar/' file.txt` (GNU long form with backup)
+ * - `sed -I 's/foo/bar/' file.txt` (BSD case-insensitive variant)
+ */
+export declare class SedFileWriteParser implements ICommandFileWriteParser {
+    readonly commandName = "sed";
+    canHandle(commandText: string): boolean;
+    extractFileWrites(commandText: string): string[];
+    /**
+     * Tokenizes a command into individual arguments, handling quotes and escapes.
+     */
+    private _tokenizeCommand;
+    /**
+     * Extracts file targets from tokenized sed command arguments.
+     * Files are generally the last non-option, non-script arguments.
+     */
+    private _extractFileTargets;
+}

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

@@ -0,0 +1,142 @@
+
+
+class SedFileWriteParser {
+    constructor() {
+        this.commandName = 'sed';
+    }
+    canHandle(commandText) {
+        if (!commandText.match(/^sed\s+/)) {
+            return false;
+        }
+        const inPlaceRegex = /(?:^|\s)(-[a-zA-Z]*[iI][a-zA-Z]*\S*|--in-place(?:=\S*)?|(-i|-I)\s*'[^']*'|(-i|-I)\s*"[^"]*")(?:\s|$)/;
+        return inPlaceRegex.test(commandText);
+    }
+    extractFileWrites(commandText) {
+        const tokens = this._tokenizeCommand(commandText);
+        return this._extractFileTargets(tokens);
+    }
+    _tokenizeCommand(commandText) {
+        const tokens = [];
+        let current = '';
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let escaped = false;
+        for (let i = 0; i < commandText.length; i++) {
+            const char = commandText[i];
+            if (escaped) {
+                current += char;
+                escaped = false;
+                continue;
+            }
+            if (char === '\\' && !inSingleQuote) {
+                escaped = true;
+                current += char;
+                continue;
+            }
+            if (char === '\'' && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+                current += char;
+                continue;
+            }
+            if (char === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+                current += char;
+                continue;
+            }
+            if (/\s/.test(char) && !inSingleQuote && !inDoubleQuote) {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+                continue;
+            }
+            current += char;
+        }
+        if (current) {
+            tokens.push(current);
+        }
+        return tokens;
+    }
+    _extractFileTargets(tokens) {
+        if (tokens.length === 0 || tokens[0] !== 'sed') {
+            return [];
+        }
+        const files = [];
+        let i = 1;
+        let foundScript = false;
+        while (i < tokens.length) {
+            const token = tokens[i];
+            if (token.startsWith('--')) {
+                if (token === '--in-place' || token.startsWith('--in-place=')) {
+                    i++;
+                    continue;
+                }
+                if (token === '--expression' || token === '--file') {
+                    i += 2;
+                    foundScript = true;
+                    continue;
+                }
+                if (token.startsWith('--expression=') || token.startsWith('--file=')) {
+                    i++;
+                    foundScript = true;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            if (token.startsWith('-') && token.length > 1 && token[1] !== '-') {
+                const flags = token.slice(1);
+                const iIndex = flags.indexOf('i');
+                const IIndex = flags.indexOf('I');
+                const inPlaceIndex = iIndex >= 0 ? iIndex : IIndex;
+                if (inPlaceIndex >= 0 && inPlaceIndex < flags.length - 1) {
+                    i++;
+                    continue;
+                }
+                if ((flags.endsWith('i') || flags.endsWith('I')) && i + 1 < tokens.length) {
+                    const nextToken = tokens[i + 1];
+                    if (nextToken === '\'\'' || nextToken === '""') {
+                        i += 2;
+                        continue;
+                    }
+                    if ((nextToken.startsWith('\'') && nextToken.endsWith('\'')) || (nextToken.startsWith('"') && nextToken.endsWith('"'))) {
+                        const unquoted = nextToken.slice(1, -1);
+                        if (unquoted.startsWith('.') && unquoted.length <= 10 && !unquoted.includes('/')) {
+                            i += 2;
+                            continue;
+                        }
+                    }
+                }
+                if (flags.includes('e') || flags.includes('f')) {
+                    const eIndex = flags.indexOf('e');
+                    const fIndex = flags.indexOf('f');
+                    const optIndex = eIndex >= 0 ? eIndex : fIndex;
+                    if (optIndex < flags.length - 1) {
+                        foundScript = true;
+                        i++;
+                        continue;
+                    }
+                    foundScript = true;
+                    i += 2;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            if (!foundScript) {
+                foundScript = true;
+                i++;
+                continue;
+            }
+            let file = token;
+            if ((file.startsWith('\'') && file.endsWith('\'')) || (file.startsWith('"') && file.endsWith('"'))) {
+                file = file.slice(1, -1);
+            }
+            files.push(file);
+            i++;
+        }
+        return files;
+    }
+}
+
+export { SedFileWriteParser };

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

@@ -0,0 +1,45 @@
+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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+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 ITerminalExecuteStrategy, type ITerminalExecuteStrategyResult } from "./executeStrategy.js";
+import type { IMarker as IXtermMarker } from "@xterm/xterm";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+/**
+ * This strategy is used when shell integration is enabled, but rich command detection was not
+ * declared by the shell script. This is the large spectrum between rich command detection and no
+ * shell integration, here are some problems that are expected:
+ *
+ * - `133;C` command executed may not happen.
+ * - `633;E` comamnd line reporting will likely not happen, so the command line contained in the
+ *   execution start and end events will be of low confidence and chances are it will be wrong.
+ * - Execution tracking may be incorrect, particularly when `executeCommand` calls are overlapped,
+ *   such as Python activating the environment at the same time as Copilot executing a command. So
+ *   the end event for the execution may actually correspond to a different command.
+ *
+ * This strategy focuses on trying to get the most accurate output given these limitations and
+ * unknowns. Basically we cannot fully trust the extension APIs in this case, so polling of the data
+ * stream is used to detect idling, and we listen to the terminal's data stream instead of the
+ * execution's data stream.
+ *
+ * This is best effort with the goal being the output is accurate, though it may contain some
+ * content above and below the command output, such as prompts or even possibly other command
+ * output. We lean on the LLM to be able to differentiate the actual output from prompts and bad
+ * output when it's not ideal.
+ */
+export declare class BasicExecuteStrategy extends Disposable implements ITerminalExecuteStrategy {
+    private readonly _instance;
+    private readonly _hasReceivedUserInput;
+    private readonly _commandDetection;
+    private readonly _configurationService;
+    private readonly _logService;
+    readonly type = "basic";
+    private readonly _startMarker;
+    private readonly _onDidCreateStartMarker;
+    onDidCreateStartMarker: Event<IXtermMarker | undefined>;
+    constructor(_instance: ITerminalInstance, _hasReceivedUserInput: () => boolean, _commandDetection: ICommandDetectionCapability, _configurationService: IConfigurationService, _logService: ITerminalLogService);
+    execute(commandLine: string, token: CancellationToken, commandId?: string, _commandLineForMetadata?: string): Promise<ITerminalExecuteStrategyResult>;
+    private _log;
+}