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

package/empty.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@codingame/monaco-vscode-xterm-addons-common",
+  "version": "24.1.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - common package depending on xterm addons",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "dependencies": {
+    "@codingame/monaco-vscode-api": "24.1.0",
+    "@xterm/addon-clipboard": "0.2.0-beta.120",
+    "@xterm/addon-image": "0.9.0-beta.137",
+    "@xterm/addon-ligatures": "0.10.0-beta.137",
+    "@xterm/addon-progress": "0.2.0-beta.43",
+    "@xterm/addon-search": "0.16.0-beta.137",
+    "@xterm/addon-serialize": "0.14.0-beta.137",
+    "@xterm/addon-unicode11": "0.9.0-beta.137",
+    "@xterm/addon-webgl": "0.19.0-beta.137"
+  },
+  "exports": {
+    ".": {
+      "default": "./empty.js"
+    },
+    "./vscode/*.css": {
+      "default": "./vscode/src/*.css"
+    },
+    "./vscode/*": {
+      "types": "./vscode/src/*.d.ts",
+      "default": "./vscode/src/*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "default": "./*.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vscode/*": [
+        "./vscode/src/*.d.ts"
+      ]
+    }
+  }
+}

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatContext.d.ts

@@ -0,0 +1,25 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatContextValueItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextPickService";
+import { IChatContextPickService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextPickService.service";
+import { IChatRequestVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export declare class ChatContextContributions extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "chat.contextContributions";
+    constructor(instantiationService: IInstantiationService, contextPickService: IChatContextPickService);
+}
+export declare class TerminalContext implements IChatContextValueItem {
+    private readonly _resource;
+    private readonly _terminalService;
+    readonly type = "valuePick";
+    readonly icon: ThemeIcon;
+    readonly label: string;
+    constructor(_resource: URI, _terminalService: ITerminalService);
+    isEnabled(widget: IChatWidget): boolean;
+    asAttachment(widget: IChatWidget): Promise<IChatRequestVariableEntry | undefined>;
+    private asValue;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatContext.js

@@ -0,0 +1,315 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isElectron } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { DiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/diffEditorInput';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { UntitledTextEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/untitled/common/untitledTextEditorInput';
+import { FileEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/editors/fileEditorInput';
+import { NotebookEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { IChatContextPickService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextPickService.service';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { toToolSetVariableEntry, toToolVariableEntry, OmittedState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { ToolSet, ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { isImage } from '../chatPasteProviders.js';
+import { convertBufferToScreenshotVariable } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/contrib/screenshot';
+import { imageToHash } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/imageUtils';
+import { ChatInstructionsPickerPick } from '../promptSyntax/attachInstructionsAction.js';
+import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+
+let ChatContextContributions = class ChatContextContributions extends Disposable {
+    static { this.ID = 'chat.contextContributions'; }
+    constructor(instantiationService, contextPickService) {
+        super();
+        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(ToolsContextPickerPick)));
+        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(ChatInstructionsPickerPick)));
+        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(OpenEditorContextValuePick)));
+        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(RelatedFilesContextPickerPick)));
+        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(ClipboardImageContextValuePick)));
+        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(ScreenshotContextValuePick)));
+    }
+};
+ChatContextContributions = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IChatContextPickService))
+], ChatContextContributions));
+class ToolsContextPickerPick {
+    constructor() {
+        this.type = 'pickerPick';
+        this.label = ( localize(4681, 'Tools...'));
+        this.icon = Codicon.tools;
+        this.ordinal = -500;
+    }
+    isEnabled(widget) {
+        return !!widget.attachmentCapabilities.supportsToolAttachments;
+    }
+    asPicker(widget) {
+        const items = [];
+        for (const [entry, enabled] of widget.input.selectedToolsModel.entriesMap.get()) {
+            if (enabled) {
+                if (entry instanceof ToolSet) {
+                    items.push({
+                        toolInfo: ToolDataSource.classify(entry.source),
+                        label: entry.referenceName,
+                        description: entry.description,
+                        asAttachment: () => toToolSetVariableEntry(entry)
+                    });
+                }
+                else {
+                    items.push({
+                        toolInfo: ToolDataSource.classify(entry.source),
+                        label: entry.toolReferenceName ?? entry.displayName,
+                        description: entry.userDescription ?? entry.modelDescription,
+                        asAttachment: () => toToolVariableEntry(entry)
+                    });
+                }
+            }
+        }
+        items.sort((a, b) => {
+            let res = a.toolInfo.ordinal - b.toolInfo.ordinal;
+            if (res === 0) {
+                res = a.toolInfo.label.localeCompare(b.toolInfo.label);
+            }
+            if (res === 0) {
+                res = a.label.localeCompare(b.label);
+            }
+            return res;
+        });
+        let lastGroupLabel;
+        const picks = [];
+        for (const item of items) {
+            if (lastGroupLabel !== item.toolInfo.label) {
+                picks.push({ type: 'separator', label: item.toolInfo.label });
+                lastGroupLabel = item.toolInfo.label;
+            }
+            picks.push(item);
+        }
+        return {
+            placeholder: ( localize(4682, 'Select a tool')),
+            picks: Promise.resolve(picks)
+        };
+    }
+}
+let OpenEditorContextValuePick = class OpenEditorContextValuePick {
+    constructor(_editorService, _labelService) {
+        this._editorService = _editorService;
+        this._labelService = _labelService;
+        this.type = 'valuePick';
+        this.label = ( localize(4683, 'Open Editors'));
+        this.icon = Codicon.file;
+        this.ordinal = 800;
+    }
+    isEnabled() {
+        return this._editorService.editors.filter(e => e instanceof FileEditorInput || e instanceof DiffEditorInput || e instanceof UntitledTextEditorInput).length > 0;
+    }
+    async asAttachment() {
+        const result = [];
+        for (const editor of this._editorService.editors) {
+            if (!(editor instanceof FileEditorInput || editor instanceof DiffEditorInput || editor instanceof UntitledTextEditorInput || editor instanceof NotebookEditorInput)) {
+                continue;
+            }
+            const uri = EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+            if (!uri) {
+                continue;
+            }
+            result.push({
+                kind: 'file',
+                id: ( uri.toString()),
+                value: uri,
+                name: this._labelService.getUriBasenameLabel(uri),
+            });
+        }
+        return result;
+    }
+};
+OpenEditorContextValuePick = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, ILabelService))
+], OpenEditorContextValuePick));
+let RelatedFilesContextPickerPick = class RelatedFilesContextPickerPick {
+    constructor(_chatEditingService, _labelService) {
+        this._chatEditingService = _chatEditingService;
+        this._labelService = _labelService;
+        this.type = 'pickerPick';
+        this.label = ( localize(4684, 'Related Files'));
+        this.icon = Codicon.sparkle;
+        this.ordinal = 300;
+    }
+    isEnabled(widget) {
+        return this._chatEditingService.hasRelatedFilesProviders() && (Boolean(widget.getInput()) || widget.attachmentModel.fileAttachments.length > 0);
+    }
+    asPicker(widget) {
+        const picks = (async () => {
+            const chatSessionResource = widget.viewModel?.sessionResource;
+            if (!chatSessionResource) {
+                return [];
+            }
+            const relatedFiles = await this._chatEditingService.getRelatedFiles(chatSessionResource, widget.getInput(), widget.attachmentModel.fileAttachments, CancellationToken.None);
+            if (!relatedFiles) {
+                return [];
+            }
+            const attachments = widget.attachmentModel.getAttachmentIDs();
+            return this._chatEditingService.getRelatedFiles(chatSessionResource, widget.getInput(), widget.attachmentModel.fileAttachments, CancellationToken.None)
+                .then((files) => (files ?? []).reduce((acc, cur) => {
+                acc.push({ type: 'separator', label: cur.group });
+                for (const file of cur.files) {
+                    const label = this._labelService.getUriBasenameLabel(file.uri);
+                    acc.push({
+                        label: label,
+                        description: this._labelService.getUriLabel(dirname(file.uri), { relative: true }),
+                        disabled: ( attachments.has(( file.uri.toString()))),
+                        asAttachment: () => {
+                            return {
+                                kind: 'file',
+                                id: ( file.uri.toString()),
+                                value: file.uri,
+                                name: label,
+                                omittedState: OmittedState.NotOmitted
+                            };
+                        }
+                    });
+                }
+                return acc;
+            }, []));
+        })();
+        return {
+            placeholder: ( localize(4685, 'Add related files to your working set')),
+            picks,
+        };
+    }
+};
+RelatedFilesContextPickerPick = ( __decorate([
+    ( __param(0, IChatEditingService)),
+    ( __param(1, ILabelService))
+], RelatedFilesContextPickerPick));
+let ClipboardImageContextValuePick = class ClipboardImageContextValuePick {
+    constructor(_clipboardService) {
+        this._clipboardService = _clipboardService;
+        this.type = 'valuePick';
+        this.label = ( localize(4686, 'Image from Clipboard'));
+        this.icon = Codicon.fileMedia;
+    }
+    async isEnabled(widget) {
+        if (!widget.attachmentCapabilities.supportsImageAttachments) {
+            return false;
+        }
+        if (!widget.input.selectedLanguageModel?.metadata.capabilities?.vision) {
+            return false;
+        }
+        const imageData = await this._clipboardService.readImage();
+        return isImage(imageData);
+    }
+    async asAttachment() {
+        const fileBuffer = await this._clipboardService.readImage();
+        return {
+            id: await imageToHash(fileBuffer),
+            name: ( localize(4687, 'Pasted Image')),
+            fullName: ( localize(4687, 'Pasted Image')),
+            value: fileBuffer,
+            kind: 'image',
+        };
+    }
+};
+ClipboardImageContextValuePick = ( __decorate([
+    ( __param(0, IClipboardService))
+], ClipboardImageContextValuePick));
+let TerminalContext = class TerminalContext {
+    constructor(_resource, _terminalService) {
+        this._resource = _resource;
+        this._terminalService = _terminalService;
+        this.type = 'valuePick';
+        this.icon = Codicon.terminal;
+        this.label = ( localize(4688, 'Terminal'));
+    }
+    isEnabled(widget) {
+        const terminal = this._terminalService.getInstanceFromResource(this._resource);
+        return !!widget.attachmentCapabilities.supportsTerminalAttachments && terminal?.isDisposed === false;
+    }
+    async asAttachment(widget) {
+        const terminal = this._terminalService.getInstanceFromResource(this._resource);
+        if (!terminal) {
+            return;
+        }
+        const params = ( new URLSearchParams(this._resource.query));
+        const command = terminal.capabilities.get(TerminalCapability.CommandDetection)?.commands.find(cmd => cmd.id === params.get('command'));
+        if (!command) {
+            return;
+        }
+        const attachment = {
+            kind: 'terminalCommand',
+            id: `terminalCommand:${Date.now()}}`,
+            value: this.asValue(command),
+            name: command.command,
+            command: command.command,
+            output: command.getOutput(),
+            exitCode: command.exitCode,
+            resource: this._resource
+        };
+        const cleanup = ( new DisposableStore());
+        let disposed = false;
+        const disposeCleanup = () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            cleanup.dispose();
+        };
+        cleanup.add(widget.attachmentModel.onDidChange(e => {
+            if (e.deleted.includes(attachment.id)) {
+                disposeCleanup();
+            }
+        }));
+        cleanup.add(terminal.onDisposed(() => {
+            widget.attachmentModel.delete(attachment.id);
+            widget.refreshParsedInput();
+            disposeCleanup();
+        }));
+        return attachment;
+    }
+    asValue(command) {
+        let value = `Command: ${command.command}`;
+        const output = command.getOutput();
+        if (output) {
+            value += `\nOutput:\n${output}`;
+        }
+        if (typeof command.exitCode === 'number') {
+            value += `\nExit Code: ${command.exitCode}`;
+        }
+        return value;
+    }
+};
+TerminalContext = ( __decorate([
+    ( __param(1, ITerminalService))
+], TerminalContext));
+let ScreenshotContextValuePick = class ScreenshotContextValuePick {
+    constructor(_hostService) {
+        this._hostService = _hostService;
+        this.type = 'valuePick';
+        this.icon = Codicon.deviceCamera;
+        this.label = (isElectron
+            ? ( localize(4689, 'Screenshot Window'))
+            : ( localize(4690, 'Screenshot')));
+    }
+    async isEnabled(widget) {
+        return !!widget.attachmentCapabilities.supportsImageAttachments && !!widget.input.selectedLanguageModel?.metadata.capabilities?.vision;
+    }
+    async asAttachment() {
+        const blob = await this._hostService.getScreenshot();
+        return blob && convertBufferToScreenshotVariable(blob);
+    }
+};
+ScreenshotContextValuePick = ( __decorate([
+    ( __param(0, IHostService))
+], ScreenshotContextValuePick));
+
+export { ChatContextContributions, TerminalContext };

package/vscode/src/vs/workbench/contrib/chat/browser/chatPasteProviders.d.ts

@@ -0,0 +1,49 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IReadonlyVSDataTransfer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/dataTransfer";
+import { HierarchicalKind } from "@codingame/monaco-vscode-api/vscode/vs/base/common/hierarchicalKind";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { DocumentPasteContext, DocumentPasteEditProvider, DocumentPasteEditsSession } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+export declare class PasteImageProvider implements DocumentPasteEditProvider {
+    private readonly chatWidgetService;
+    private readonly extensionService;
+    private readonly fileService;
+    private readonly environmentService;
+    private readonly logService;
+    private readonly imagesFolder;
+    readonly kind: HierarchicalKind;
+    readonly providedPasteEditKinds: HierarchicalKind[];
+    readonly copyMimeTypes: never[];
+    readonly pasteMimeTypes: string[];
+    constructor(chatWidgetService: IChatWidgetService, extensionService: IExtensionService, fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService);
+    provideDocumentPasteEdits(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, context: DocumentPasteContext, token: CancellationToken): Promise<DocumentPasteEditsSession | undefined>;
+}
+export declare function isImage(array: Uint8Array): boolean;
+export declare class CopyTextProvider implements DocumentPasteEditProvider {
+    readonly providedPasteEditKinds: never[];
+    readonly copyMimeTypes: string[];
+    readonly pasteMimeTypes: never[];
+    prepareDocumentPaste(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): Promise<undefined | IReadonlyVSDataTransfer>;
+}
+export declare class PasteTextProvider implements DocumentPasteEditProvider {
+    private readonly chatWidgetService;
+    private readonly modelService;
+    readonly kind: HierarchicalKind;
+    readonly providedPasteEditKinds: HierarchicalKind[];
+    readonly copyMimeTypes: never[];
+    readonly pasteMimeTypes: string[];
+    constructor(chatWidgetService: IChatWidgetService, modelService: IModelService);
+    provideDocumentPasteEdits(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, _context: DocumentPasteContext, token: CancellationToken): Promise<DocumentPasteEditsSession | undefined>;
+}
+export declare class ChatPasteProvidersFeature extends Disposable {
+    constructor(instaService: IInstantiationService, languageFeaturesService: ILanguageFeaturesService, chatWidgetService: IChatWidgetService, extensionService: IExtensionService, fileService: IFileService, modelService: IModelService, environmentService: IEnvironmentService, logService: ILogService);
+}