@codingame/monaco-vscode-xterm-addons-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/pickers/promptFilePickers.js

@@ -0,0 +1,468 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { extUri, dirname, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { getCleanPromptName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { PromptsType, AGENT_DOCUMENTATION_URL, INSTRUCTIONS_DOCUMENTATION_URL, PROMPT_DOCUMENTATION_URL } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { NEW_PROMPT_COMMAND_ID, NEW_INSTRUCTIONS_COMMAND_ID, NEW_AGENT_COMMAND_ID } from '../newPromptFileActions.js';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { askForPromptFileName } from './askForPromptName.js';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { askForPromptSourceFolder } from './askForPromptSourceFolder.js';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { PromptsConfig } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { PromptFileRewriter } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/promptSyntax/promptFileRewriter';
+
+function newHelpButton(type) {
+    const iconClass = ThemeIcon.asClassName(Codicon.question);
+    switch (type) {
+        case PromptsType.prompt:
+            return {
+                tooltip: ( localize(5794, "Show help on prompt files")),
+                helpURI: ( URI.parse(PROMPT_DOCUMENTATION_URL)),
+                iconClass
+            };
+        case PromptsType.instructions:
+            return {
+                tooltip: ( localize(5795, "Show help on instruction files")),
+                helpURI: ( URI.parse(INSTRUCTIONS_DOCUMENTATION_URL)),
+                iconClass
+            };
+        case PromptsType.agent:
+            return {
+                tooltip: ( localize(5796, "Show help on custom agent files")),
+                helpURI: ( URI.parse(AGENT_DOCUMENTATION_URL)),
+                iconClass
+            };
+    }
+}
+function isHelpButton(button) {
+    return button.helpURI !== undefined;
+}
+function isPromptFileItem(item) {
+    return item.type === 'item' && !!item.promptFileUri;
+}
+const NEW_PROMPT_FILE_OPTION = {
+    type: 'item',
+    label: `$(plus) ${( localize(5797, 'New prompt file...'))}`,
+    pickable: false,
+    alwaysShow: true,
+    buttons: [newHelpButton(PromptsType.prompt)],
+    commandId: NEW_PROMPT_COMMAND_ID,
+};
+const NEW_INSTRUCTIONS_FILE_OPTION = {
+    type: 'item',
+    label: `$(plus) ${( localize(5798, 'New instruction file...'))}`,
+    pickable: false,
+    alwaysShow: true,
+    buttons: [newHelpButton(PromptsType.instructions)],
+    commandId: NEW_INSTRUCTIONS_COMMAND_ID,
+};
+const UPDATE_INSTRUCTIONS_OPTION = {
+    type: 'item',
+    label: `$(refresh) ${( localize(5799, 'Generate agent instructions...'))}`,
+    pickable: false,
+    alwaysShow: true,
+    buttons: [newHelpButton(PromptsType.instructions)],
+    commandId: 'workbench.action.chat.generateInstructions',
+};
+const NEW_AGENT_FILE_OPTION = {
+    type: 'item',
+    label: `$(plus) ${( localize(5800, 'Create new custom agent...'))}`,
+    pickable: false,
+    alwaysShow: true,
+    buttons: [newHelpButton(PromptsType.agent)],
+    commandId: NEW_AGENT_COMMAND_ID,
+};
+const EDIT_BUTTON = {
+    tooltip: ( localize(5801, "Open in Editor")),
+    iconClass: ThemeIcon.asClassName(Codicon.fileCode),
+};
+const DELETE_BUTTON = {
+    tooltip: ( localize(5802, "Delete")),
+    iconClass: ThemeIcon.asClassName(Codicon.trash),
+};
+const RENAME_BUTTON = {
+    tooltip: ( localize(5803, "Move and/or Rename")),
+    iconClass: ThemeIcon.asClassName(Codicon.replace),
+};
+const COPY_BUTTON = {
+    tooltip: ( localize(5804, "Copy")),
+    iconClass: ThemeIcon.asClassName(Codicon.copy),
+};
+const MAKE_VISIBLE_BUTTON = {
+    tooltip: ( localize(5805, "Hidden from chat view agent picker. Click to show.")),
+    iconClass: ThemeIcon.asClassName(Codicon.eyeClosed),
+    alwaysVisible: true,
+};
+const MAKE_INVISIBLE_BUTTON = {
+    tooltip: ( localize(5806, "Hide from agent picker")),
+    iconClass: ThemeIcon.asClassName(Codicon.eyeClosed),
+};
+let PromptFilePickers = class PromptFilePickers {
+    constructor(_quickInputService, _openerService, _fileService, _dialogService, _commandService, _instaService, _promptsService, _labelService, _configurationService) {
+        this._quickInputService = _quickInputService;
+        this._openerService = _openerService;
+        this._fileService = _fileService;
+        this._dialogService = _dialogService;
+        this._commandService = _commandService;
+        this._instaService = _instaService;
+        this._promptsService = _promptsService;
+        this._labelService = _labelService;
+        this._configurationService = _configurationService;
+    }
+    async selectPromptFile(options) {
+        const cts = ( new CancellationTokenSource());
+        const quickPick = this._quickInputService.createQuickPick({ useSeparators: true });
+        quickPick.busy = true;
+        quickPick.placeholder = ( localize(5807, 'Searching file system...'));
+        try {
+            const fileOptions = await this._createPromptPickItems(options, cts.token);
+            const activeItem = options.resource && fileOptions.find(f => f.type === 'item' && extUri.isEqual(f.promptFileUri, options.resource));
+            if (activeItem) {
+                quickPick.activeItems = [activeItem];
+            }
+            quickPick.placeholder = options.placeholder;
+            quickPick.matchOnDescription = true;
+            quickPick.items = fileOptions;
+        }
+        finally {
+            quickPick.busy = false;
+        }
+        return ( new Promise(resolve => {
+            const disposables = ( new DisposableStore());
+            let isResolved = false;
+            let isClosed = false;
+            disposables.add(quickPick);
+            disposables.add(cts);
+            const refreshItems = async () => {
+                const active = quickPick.activeItems;
+                const newItems = await this._createPromptPickItems(options, CancellationToken.None);
+                quickPick.items = newItems;
+                quickPick.activeItems = active;
+            };
+            disposables.add(quickPick.onDidAccept(async () => {
+                const { selectedItems } = quickPick;
+                const { keyMods } = quickPick;
+                const selectedItem = selectedItems[0];
+                if (isPromptFileItem(selectedItem)) {
+                    resolve({ promptFile: selectedItem.promptFileUri, keyMods: { ...keyMods } });
+                    isResolved = true;
+                }
+                else {
+                    if (selectedItem.commandId) {
+                        await this._commandService.executeCommand(selectedItem.commandId);
+                        return;
+                    }
+                }
+                quickPick.hide();
+            }));
+            disposables.add(quickPick.onDidTriggerItemButton(async (e) => {
+                const shouldRefresh = await this._handleButtonClick(quickPick, e, options);
+                if (!isClosed && shouldRefresh) {
+                    await refreshItems();
+                }
+            }));
+            disposables.add(quickPick.onDidHide(() => {
+                if (!quickPick.ignoreFocusOut) {
+                    disposables.dispose();
+                    isClosed = true;
+                    if (!isResolved) {
+                        resolve(undefined);
+                        isResolved = true;
+                    }
+                }
+            }));
+            quickPick.show();
+        }));
+    }
+    async _createPromptPickItems(options, token) {
+        const buttons = [];
+        if (options.optionEdit !== false) {
+            buttons.push(EDIT_BUTTON);
+        }
+        if (options.optionCopy !== false) {
+            buttons.push(COPY_BUTTON);
+        }
+        if (options.optionRename !== false) {
+            buttons.push(RENAME_BUTTON);
+        }
+        if (options.optionDelete !== false) {
+            buttons.push(DELETE_BUTTON);
+        }
+        const result = [];
+        if (options.optionNew !== false) {
+            result.push(...this._getNewItems(options.type));
+        }
+        let getVisibility = () => undefined;
+        if (options.optionVisibility) {
+            const disabled = this._promptsService.getDisabledPromptFiles(options.type);
+            getVisibility = p => !( disabled.has(p.uri));
+        }
+        const locals = await this._promptsService.listPromptFilesForStorage(options.type, PromptsStorage.local, token);
+        if (locals.length) {
+            result.push({ type: 'separator', label: ( localize(5808, "Workspace")) });
+            result.push(...(await Promise.all(( locals.map(l => this._createPromptPickItem(l, buttons, getVisibility(l), token))))));
+        }
+        let agentInstructionFiles = [];
+        if (options.type === PromptsType.instructions) {
+            const useNestedAgentMD = this._configurationService.getValue(PromptsConfig.USE_NESTED_AGENT_MD);
+            const agentInstructionUris = [
+                ...(await this._promptsService.listCopilotInstructionsMDs(token)),
+                ...(await this._promptsService.listAgentMDs(token, !!useNestedAgentMD))
+            ];
+            agentInstructionFiles = ( agentInstructionUris.map(uri => {
+                const folderName = this._labelService.getUriLabel(dirname(uri), { relative: true });
+                const shouldShowFolderPath = folderName?.toLowerCase() !== '.github';
+                return {
+                    uri,
+                    description: shouldShowFolderPath ? folderName : undefined,
+                    storage: PromptsStorage.local,
+                    type: options.type
+                };
+            }));
+        }
+        if (agentInstructionFiles.length) {
+            const agentButtons = buttons.filter(b => b !== RENAME_BUTTON);
+            result.push({ type: 'separator', label: ( localize(5809, "Agent Instructions")) });
+            result.push(...(await Promise.all(( agentInstructionFiles.map(l => this._createPromptPickItem(l, agentButtons, getVisibility(l), token))))));
+        }
+        const exts = await this._promptsService.listPromptFilesForStorage(options.type, PromptsStorage.extension, token);
+        if (exts.length) {
+            result.push({ type: 'separator', label: ( localize(5810, "Extensions")) });
+            const extButtons = [];
+            if (options.optionEdit !== false) {
+                extButtons.push(EDIT_BUTTON);
+            }
+            if (options.optionCopy !== false) {
+                extButtons.push(COPY_BUTTON);
+            }
+            result.push(...(await Promise.all(( exts.map(e => this._createPromptPickItem(e, extButtons, getVisibility(e), token))))));
+        }
+        const users = await this._promptsService.listPromptFilesForStorage(options.type, PromptsStorage.user, token);
+        if (users.length) {
+            result.push({ type: 'separator', label: ( localize(5811, "User Data")) });
+            result.push(...(await Promise.all(( users.map(u => this._createPromptPickItem(u, buttons, getVisibility(u), token))))));
+        }
+        return result;
+    }
+    _getNewItems(type) {
+        switch (type) {
+            case PromptsType.prompt:
+                return [NEW_PROMPT_FILE_OPTION];
+            case PromptsType.instructions:
+                return [NEW_INSTRUCTIONS_FILE_OPTION, UPDATE_INSTRUCTIONS_OPTION];
+            case PromptsType.agent:
+                return [NEW_AGENT_FILE_OPTION];
+            default:
+                throw ( new Error(`Unknown prompt type '${type}'.`));
+        }
+    }
+    async _createPromptPickItem(promptFile, buttons, visibility, token) {
+        const parsedPromptFile = await this._promptsService.parseNew(promptFile.uri, token).catch(() => undefined);
+        let promptName = parsedPromptFile?.header?.name ?? promptFile.name ?? getCleanPromptName(promptFile.uri);
+        const promptDescription = parsedPromptFile?.header?.description ?? promptFile.description;
+        let tooltip;
+        switch (promptFile.storage) {
+            case PromptsStorage.extension:
+                tooltip = promptFile.extension.displayName ?? promptFile.extension.id;
+                break;
+            case PromptsStorage.local:
+                tooltip = this._labelService.getUriLabel(dirname(promptFile.uri), { relative: true });
+                break;
+            case PromptsStorage.user:
+                tooltip = undefined;
+                break;
+        }
+        let iconClass;
+        if (visibility === false) {
+            buttons = (buttons ?? []).concat(MAKE_VISIBLE_BUTTON);
+            promptName = ( localize(5812, "{0} (hidden)", promptName));
+            tooltip = ( localize(5813, "Hidden from chat view agent picker"));
+        }
+        else if (visibility === true) {
+            buttons = (buttons ?? []).concat(MAKE_INVISIBLE_BUTTON);
+        }
+        return {
+            id: ( promptFile.uri.toString()),
+            type: 'item',
+            label: promptName,
+            description: promptDescription,
+            iconClass,
+            tooltip,
+            promptFileUri: promptFile.uri,
+            buttons,
+        };
+    }
+    async keepQuickPickOpen(quickPick, work) {
+        const previousIgnoreFocusOut = quickPick.ignoreFocusOut;
+        quickPick.ignoreFocusOut = true;
+        try {
+            return await work();
+        }
+        finally {
+            quickPick.ignoreFocusOut = previousIgnoreFocusOut;
+            quickPick.show();
+        }
+    }
+    async _handleButtonClick(quickPick, context, options) {
+        const { item, button } = context;
+        if (!isPromptFileItem(item)) {
+            if (isHelpButton(button)) {
+                await this._openerService.open(button.helpURI);
+                return false;
+            }
+            throw ( new Error(`Unknown button '${JSON.stringify(button)}'.`));
+        }
+        const value = item.promptFileUri;
+        if (button === EDIT_BUTTON) {
+            await this._openerService.open(value);
+            return false;
+        }
+        if (button === RENAME_BUTTON || button === COPY_BUTTON) {
+            return await this.keepQuickPickOpen(quickPick, async () => {
+                const currentFolder = dirname(value);
+                const isMove = button === RENAME_BUTTON && quickPick.keyMods.ctrlCmd;
+                const newFolder = await this._instaService.invokeFunction(askForPromptSourceFolder, options.type, currentFolder, isMove);
+                if (!newFolder) {
+                    return false;
+                }
+                const newName = await this._instaService.invokeFunction(askForPromptFileName, options.type, newFolder.uri, item.label);
+                if (!newName) {
+                    return false;
+                }
+                const newFile = joinPath(newFolder.uri, newName);
+                if (isMove) {
+                    await this._fileService.move(value, newFile);
+                }
+                else {
+                    await this._fileService.copy(value, newFile);
+                }
+                await this._openerService.open(newFile);
+                await this._instaService.createInstance(PromptFileRewriter).openAndRewriteName(newFile, getCleanPromptName(newFile), CancellationToken.None);
+                return true;
+            });
+        }
+        if (button === DELETE_BUTTON) {
+            return await this.keepQuickPickOpen(quickPick, async () => {
+                const filename = getCleanPromptName(value);
+                const message = ( localize(5814, "Are you sure you want to delete '{0}'?", filename));
+                const { confirmed } = await this._dialogService.confirm({ message });
+                if (!confirmed) {
+                    return false;
+                }
+                await this._fileService.del(value);
+                return true;
+            });
+        }
+        if (button === MAKE_VISIBLE_BUTTON || button === MAKE_INVISIBLE_BUTTON) {
+            const disabled = this._promptsService.getDisabledPromptFiles(options.type);
+            if (button === MAKE_VISIBLE_BUTTON) {
+                disabled.delete(value);
+            }
+            else {
+                disabled.add(value);
+            }
+            this._promptsService.setDisabledPromptFiles(options.type, disabled);
+            return true;
+        }
+        throw ( new Error(`Unknown button '${JSON.stringify(button)}'.`));
+    }
+    async managePromptFiles(type, placeholder) {
+        const cts = ( new CancellationTokenSource());
+        const quickPick = this._quickInputService.createQuickPick({ useSeparators: true });
+        quickPick.placeholder = placeholder;
+        quickPick.canSelectMany = true;
+        quickPick.matchOnDescription = true;
+        quickPick.sortByLabel = false;
+        quickPick.busy = true;
+        const options = {
+            placeholder: '',
+            type,
+            optionNew: true,
+            optionEdit: true,
+            optionDelete: true,
+            optionRename: true,
+            optionCopy: true,
+            optionVisibility: false
+        };
+        try {
+            const items = await this._createPromptPickItems(options, cts.token);
+            quickPick.items = items;
+        }
+        finally {
+            quickPick.busy = false;
+        }
+        return ( new Promise(resolve => {
+            const disposables = ( new DisposableStore());
+            disposables.add(quickPick);
+            disposables.add(cts);
+            let isClosed = false;
+            let isResolved = false;
+            const refreshItems = async () => {
+                const active = quickPick.activeItems;
+                const newItems = await this._createPromptPickItems(options, CancellationToken.None);
+                quickPick.items = newItems;
+                quickPick.activeItems = active;
+            };
+            disposables.add(quickPick.onDidAccept(async () => {
+                const clickedItem = quickPick.activeItems;
+                if (clickedItem.length === 1 && clickedItem[0].commandId) {
+                    const commandId = clickedItem[0].commandId;
+                    await this.keepQuickPickOpen(quickPick, async () => {
+                        await this._commandService.executeCommand(commandId);
+                    });
+                    if (!isClosed) {
+                        await refreshItems();
+                    }
+                    return;
+                }
+                isResolved = true;
+                resolve(true);
+                quickPick.hide();
+            }));
+            disposables.add(quickPick.onDidTriggerItemButton(async (e) => {
+                const shouldRefresh = await this._handleButtonClick(quickPick, e, options);
+                if (!isClosed && shouldRefresh) {
+                    await refreshItems();
+                }
+            }));
+            disposables.add(quickPick.onDidHide(() => {
+                if (!quickPick.ignoreFocusOut) {
+                    disposables.dispose();
+                    isClosed = true;
+                    if (!isResolved) {
+                        resolve(false);
+                        isResolved = true;
+                    }
+                }
+            }));
+            quickPick.show();
+        }));
+    }
+};
+PromptFilePickers = ( __decorate([
+    ( __param(0, IQuickInputService)),
+    ( __param(1, IOpenerService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IDialogService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IPromptsService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IConfigurationService))
+], PromptFilePickers));
+
+export { PromptFilePickers };

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalUri.d.ts

@@ -0,0 +1,18 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITerminalInstance } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal";
+export interface ITerminalUriMetadata {
+    title?: string;
+    commandId?: string;
+    commandLine?: string;
+}
+export declare function parseTerminalUri(resource: URI): ITerminalIdentifier;
+export declare function getTerminalUri(workspaceId: string, instanceId: number, title?: string, commandId?: string): URI;
+export interface ITerminalIdentifier {
+    workspaceId: string;
+    instanceId: number | undefined;
+}
+export interface IPartialDragEvent {
+    dataTransfer: Pick<DataTransfer, "getData"> | null;
+}
+export declare function getTerminalResourcesFromDragEvent(event: IPartialDragEvent): URI[] | undefined;
+export declare function getInstanceFromResource<T extends Pick<ITerminalInstance, "resource">>(instances: T[], resource: URI | undefined): T | undefined;

package/vscode/src/vs/workbench/contrib/terminal/browser/terminalUri.js

@@ -0,0 +1,48 @@
+
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { TerminalDataTransfers } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal';
+
+function parseTerminalUri(resource) {
+    const [, workspaceId, instanceId] = resource.path.split('/');
+    if (!workspaceId || !Number.parseInt(instanceId)) {
+        throw ( new Error(`Could not parse terminal uri for resource ${resource}`));
+    }
+    return { workspaceId, instanceId: Number.parseInt(instanceId) };
+}
+function getTerminalUri(workspaceId, instanceId, title, commandId) {
+    const params = ( new URLSearchParams());
+    if (commandId) {
+        params.set('command', commandId);
+    }
+    return ( URI.from({
+        scheme: Schemas.vscodeTerminal,
+        path: `/${workspaceId}/${instanceId}`,
+        fragment: title || undefined,
+        query: commandId ? ( params.toString()) : undefined
+    }));
+}
+function getTerminalResourcesFromDragEvent(event) {
+    const resources = event.dataTransfer?.getData(TerminalDataTransfers.Terminals);
+    if (resources) {
+        const json = JSON.parse(resources);
+        const result = [];
+        for (const entry of json) {
+            result.push(( URI.parse(entry)));
+        }
+        return result.length === 0 ? undefined : result;
+    }
+    return undefined;
+}
+function getInstanceFromResource(instances, resource) {
+    if (resource) {
+        for (const instance of instances) {
+            if (instance.resource.path === resource.path) {
+                return instance;
+            }
+        }
+    }
+    return undefined;
+}
+
+export { getInstanceFromResource, getTerminalResourcesFromDragEvent, getTerminalUri, parseTerminalUri };

package/vscode/src/vs/workbench/contrib/terminal/browser/xterm/decorationAddon.d.ts

@@ -0,0 +1,80 @@
+import type { IDecoration, ITerminalAddon, Terminal } from "@xterm/xterm";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAccessibilitySignalService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service";
+import { IClipboardService } from "@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IMarkProperties, ITerminalCapabilityStore, ITerminalCommand } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { type IDecorationAddon } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IChatContextPickService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextPickService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export declare class DecorationAddon extends Disposable implements ITerminalAddon, IDecorationAddon {
+    private readonly _resource;
+    private readonly _capabilities;
+    private readonly _clipboardService;
+    private readonly _contextMenuService;
+    private readonly _configurationService;
+    private readonly _themeService;
+    private readonly _openerService;
+    private readonly _quickInputService;
+    private readonly _commandService;
+    private readonly _accessibilitySignalService;
+    private readonly _notificationService;
+    private readonly _hoverService;
+    private readonly _contextPickService;
+    private readonly _chatWidgetService;
+    private readonly _instantiationService;
+    protected _terminal: Terminal | undefined;
+    private _capabilityDisposables;
+    private _decorations;
+    private _placeholderDecoration;
+    private _showGutterDecorations?;
+    private _showOverviewRulerDecorations?;
+    private readonly _registeredMenuItems;
+    private readonly _onDidRequestRunCommand;
+    readonly onDidRequestRunCommand: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<{
+        command: ITerminalCommand;
+        noNewLine?: boolean;
+    }>;
+    private readonly _onDidRequestCopyAsHtml;
+    readonly onDidRequestCopyAsHtml: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<{
+        command: ITerminalCommand;
+    }>;
+    constructor(_resource: URI | undefined, _capabilities: ITerminalCapabilityStore, _clipboardService: IClipboardService, _contextMenuService: IContextMenuService, _configurationService: IConfigurationService, _themeService: IThemeService, _openerService: IOpenerService, _quickInputService: IQuickInputService, lifecycleService: ILifecycleService, _commandService: ICommandService, _accessibilitySignalService: IAccessibilitySignalService, _notificationService: INotificationService, _hoverService: IHoverService, _contextPickService: IChatContextPickService, _chatWidgetService: IChatWidgetService, _instantiationService: IInstantiationService);
+    private _createCapabilityDisposables;
+    private _removeCapabilityDisposables;
+    registerMarkDecoration(mark: IMarkProperties): IDecoration | undefined;
+    private _updateDecorationVisibility;
+    private _disposeAllDecorations;
+    private _updateGutterDecorationVisibility;
+    private _updateCommandDecorationVisibility;
+    refreshLayouts(): void;
+    private _refreshStyles;
+    private _dispose;
+    private _clearPlaceholder;
+    clearDecorations(): void;
+    private _attachToCommandCapability;
+    private _getCommandDetectionListeners;
+    activate(terminal: Terminal): void;
+    registerCommandDecoration(command?: ITerminalCommand, beforeCommandExecution?: boolean, markProperties?: IMarkProperties): IDecoration | undefined;
+    registerMenuItems(command: ITerminalCommand, items: IAction[]): IDisposable;
+    private _createDisposables;
+    private _createHover;
+    private _updateClasses;
+    private _createContextMenu;
+    private _getContextMenuActions;
+    private _getCommandActions;
+    private _createAttachToChatAction;
+    private _showToggleVisibilityQuickPick;
+    private _getDecorationCssColor;
+}