@codingame/monaco-vscode-xterm-addons-common 36.2.7 → 37.2.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/editor/chatPasteProviders.js

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { alert, status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { VSDataTransfer, createStringDataTransferItem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/dataTransfer';
 import { convertHtmlToMarkdown } from '../../../../../../../base/browser/htmlToMarkdown.js';
@@ -12,6 +12,7 @@ import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/netw
 import { joinPath, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { SymbolKinds, DocumentPasteTriggerKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
 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';
@@ -21,27 +22,29 @@ import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { isProposedApiEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
-import { isImageVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+import { toPasteVariableEntry, ChatPasteAttachmentMetadata, isImageVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
 import { chatVariableLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
-import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { getDynamicVariablesForWidget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatVariables';
-import { ChatDynamicVariableModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables';
+import { IChatPasteTargetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { isChatInputModel, ChatConfiguration, chatInputSchemes } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { cleanupOldImages, createFileForMedia, resizeImage, imageToHash } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatImageUtils';
 
-var CopyAttachmentsProvider_1;
 const COPY_MIME_TYPES = "application/vnd.code.additional-editor-data";
+const pastedTextArtifactDefaultMinLength = 10000;
+const CHAT_ATTACHMENT_MIME_TYPE = "application/vnd.chat.attachment+json";
+const GITHUB_ISSUE_OR_PULL_REQUEST_URL_PATTERN = /\bhttps?:\/\/(?:www\.)?github\.com\/(?<owner>[\w.-]+)\/(?<repo>[\w.-]+)\/(?<kind>issues|pull)\/(?<number>\d+)(?![\w-])/gi;
 let PasteImageProvider = class PasteImageProvider {
     constructor(
-        chatWidgetService,
+        pasteTargetService,
         extensionService,
         fileService,
         environmentService,
         logService
     ) {
-        this.chatWidgetService = chatWidgetService;
+        this.pasteTargetService = pasteTargetService;
         this.extensionService = extensionService;
         this.fileService = fileService;
         this.environmentService = environmentService;
@@ -54,7 +57,7 @@ let PasteImageProvider = class PasteImageProvider {
         cleanupOldImages(this.fileService, this.logService, this.imagesFolder);
     }
     async provideDocumentPasteEdits(model, ranges, dataTransfer, context, token) {
-        if (!( this.extensionService.extensions.some(ext => isProposedApiEnabled(ext)))) {
+        if (!( this.extensionService.extensions.some(ext => isProposedApiEnabled(ext, "chatReferenceBinaryData")))) {
             return;
         }
         const supportedMimeTypes = [
@@ -81,12 +84,12 @@ let PasteImageProvider = class PasteImageProvider {
         if (token.isCancellationRequested || !currClipboard) {
             return;
         }
-        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-        if (!widget) {
+        const target = this.pasteTargetService.getTarget(model.uri);
+        if (!target) {
             return;
         }
-        const attachedVariables = widget.attachmentModel.attachments;
-        const displayName = ( localize(8339, "Pasted Image"));
+        const attachedVariables = target.attachments;
+        const displayName = ( localize(10028, "Pasted Image"));
         let tempDisplayName = displayName;
         for (let appendValue = 2; ( attachedVariables.some(attachment => attachment.name === tempDisplayName)); appendValue++)
         {
@@ -104,11 +107,11 @@ let PasteImageProvider = class PasteImageProvider {
         if (token.isCancellationRequested || !scaledImageContext) {
             return;
         }
-        const currentContextIds = widget.attachmentModel.getAttachmentIDs();
+        const currentContextIds = ( new Set(( target.attachments.map(attachment => attachment.id))));
         if (( currentContextIds.has(scaledImageContext.id))) {
             return;
         }
-        const edit = createCustomPasteEdit(model, [scaledImageContext], mimeType, this.kind, ( localize(8340, "Pasted Image Attachment")), this.chatWidgetService);
+        const edit = createCustomPasteEdit(model, [scaledImageContext], mimeType, this.kind, ( localize(10029, "Pasted Image Attachment")), this.pasteTargetService);
         return createEditSession(edit);
     }
 };
@@ -155,7 +158,7 @@ let CopyTextProvider = class CopyTextProvider {
         this.pasteMimeTypes = [];
     }
     async prepareDocumentPaste(model, ranges, dataTransfer, token) {
-        if (model.uri.scheme === Schemas.vscodeChatInput) {
+        if (isChatInputModel(model.uri)) {
             return;
         }
         const customDataTransfer = ( new VSDataTransfer());
@@ -191,50 +194,41 @@ let CopyTextProvider = class CopyTextProvider {
 };
 CopyTextProvider = ( __decorate([( __param(0, IModelService)), ( __param(1, ILanguageFeaturesService)), ( __param(2, IOutlineModelService))], CopyTextProvider));
 let CopyAttachmentsProvider = class CopyAttachmentsProvider {
-    static {
-        CopyAttachmentsProvider_1 = this;
-    }
-    static {
-        this.ATTACHMENT_MIME_TYPE = "application/vnd.chat.attachment+json";
-    }
-    constructor(chatWidgetService) {
-        this.chatWidgetService = chatWidgetService;
+    constructor(pasteTargetService) {
+        this.pasteTargetService = pasteTargetService;
         this.kind = ( new HierarchicalKind("chat.attach.attachments"));
         this.providedPasteEditKinds = [this.kind];
-        this.copyMimeTypes = [CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE];
-        this.pasteMimeTypes = [CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE];
+        this.copyMimeTypes = [CHAT_ATTACHMENT_MIME_TYPE];
+        this.pasteMimeTypes = [CHAT_ATTACHMENT_MIME_TYPE];
     }
     async prepareDocumentPaste(model, _ranges, _dataTransfer, _token) {
-        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-        if (!widget || !widget.viewModel) {
+        const target = this.pasteTargetService.getTarget(model.uri);
+        if (!target) {
             return undefined;
         }
-        const attachments = widget.attachmentModel.attachments;
-        const dynamicVariables = getDynamicVariablesForWidget(widget);
+        const dynamicVariables = target.inlineReferences;
+        const referencedIds = ( new Set(( dynamicVariables.map(variable => variable.id))));
+        const attachments = ( target.attachments.map(attachment => attachment.range && !( referencedIds.has(attachment.id)) ? {
+            ...attachment,
+            range: undefined
+        } : attachment));
         if (attachments.length === 0 && dynamicVariables.length === 0) {
             return undefined;
         }
         const result = ( new VSDataTransfer());
-        result.append(
-            CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE,
-            createStringDataTransferItem(JSON.stringify({
-                attachments,
-                dynamicVariables
-            }))
-        );
+        result.append(CHAT_ATTACHMENT_MIME_TYPE, createStringDataTransferItem(JSON.stringify({
+            attachments,
+            dynamicVariables
+        })));
         return result;
     }
     async provideDocumentPasteEdits(model, _ranges, dataTransfer, _context, token) {
-        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-        if (!widget || !widget.viewModel) {
-            return undefined;
-        }
-        const chatDynamicVariable = widget.getContrib(ChatDynamicVariableModel.ID);
-        if (!chatDynamicVariable) {
+        const target = this.pasteTargetService.getTarget(model.uri);
+        if (!target) {
             return undefined;
         }
         const text = dataTransfer.get(Mimes.text);
-        const data = dataTransfer.get(CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE);
+        const data = dataTransfer.get(CHAT_ATTACHMENT_MIME_TYPE);
         const rawData = await data?.asString();
         const textdata = await text?.asString();
         if (textdata === undefined || rawData === undefined) {
@@ -252,9 +246,9 @@ let CopyAttachmentsProvider = class CopyAttachmentsProvider {
         }
         const edit = {
             insertText: textdata,
-            title: ( localize(8341, "Insert Prompt & Attachments")),
+            title: ( localize(10030, "Insert Prompt & Attachments")),
             kind: this.kind,
-            handledMimeType: CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE,
+            handledMimeType: CHAT_ATTACHMENT_MIME_TYPE,
             additionalEdit: {
                 edits: []
             }
@@ -262,85 +256,205 @@ let CopyAttachmentsProvider = class CopyAttachmentsProvider {
         edit.additionalEdit?.edits.push({
             resource: model.uri,
             redo: () => {
-                widget.attachmentModel.addContext(...pastedData.attachments);
+                target.addAttachments(pastedData.attachments);
                 for (const dynamicVariable of pastedData.dynamicVariables) {
-                    chatDynamicVariable?.addReference(dynamicVariable);
+                    target.addInlineReference(dynamicVariable);
                 }
-                widget.refreshParsedInput();
             },
             undo: () => {
-                widget.attachmentModel.delete(...( pastedData.attachments.map(c => c.id)));
-                widget.refreshParsedInput();
+                target.removeAttachments(( pastedData.attachments.map(c => c.id)));
             }
         });
         return createEditSession(edit);
     }
 };
-CopyAttachmentsProvider = CopyAttachmentsProvider_1 = ( __decorate([( __param(0, IChatWidgetService))], CopyAttachmentsProvider));
+CopyAttachmentsProvider = ( __decorate([( __param(0, IChatPasteTargetService))], CopyAttachmentsProvider));
+function getGitHubIssueOrPullRequestAttachments(input, metadata) {
+    const attachments = [];
+    const ids = ( new Set());
+    for (const match of input.matchAll(GITHUB_ISSUE_OR_PULL_REQUEST_URL_PATTERN)) {
+        const groups = match.groups;
+        const number = Number(groups?.["number"]);
+        if (!groups || !Number.isSafeInteger(number) || number <= 0) {
+            continue;
+        }
+        const owner = groups["owner"];
+        const repo = groups["repo"];
+        const kind = groups["kind"].toLowerCase();
+        const uri = `https://github.com/${owner}/${repo}/${kind}/${number}`;
+        const id = `github-context:${uri}`;
+        if (( ids.has(id))) {
+            continue;
+        }
+        ids.add(id);
+        attachments.push({
+            kind: "generic",
+            id,
+            icon: kind === "issues" ? Codicon.issues : Codicon.gitPullRequest,
+            name: `${owner}/${repo}#${number}`,
+            value: `GitHub context: ${uri}`,
+            _meta: metadata
+        });
+    }
+    return attachments;
+}
 class PasteTextProvider {
-    constructor(chatWidgetService, modelService) {
-        this.chatWidgetService = chatWidgetService;
+    constructor(pasteTargetService, modelService, logService, configurationService) {
+        this.pasteTargetService = pasteTargetService;
         this.modelService = modelService;
+        this.logService = logService;
+        this.configurationService = configurationService;
         this.kind = ( new HierarchicalKind("chat.attach.text"));
         this.providedPasteEditKinds = [this.kind];
         this.copyMimeTypes = [];
-        this.pasteMimeTypes = [COPY_MIME_TYPES];
+        this.pasteMimeTypes = [COPY_MIME_TYPES, Mimes.text];
     }
     async provideDocumentPasteEdits(model, ranges, dataTransfer, _context, token) {
-        if (model.uri.scheme !== Schemas.vscodeChatInput) {
+        if (!isChatInputModel(model.uri)) {
             return;
         }
         const text = dataTransfer.get(Mimes.text);
         const editorData = dataTransfer.get("vscode-editor-data");
         const additionalEditorData = dataTransfer.get(COPY_MIME_TYPES);
-        if (!editorData || !text || !additionalEditorData) {
+        if (!text) {
             return;
         }
         const textdata = await text.asString();
-        const metadata = JSON.parse(await editorData.asString());
-        const additionalData = JSON.parse(await additionalEditorData.asString());
-        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-        if (!widget) {
+        const target = this.pasteTargetService.getTarget(model.uri);
+        if (!target) {
             return;
         }
-        const start = additionalData.range.startLineNumber;
-        const end = additionalData.range.endLineNumber;
-        if (start === end) {
-            const textModel = this.modelService.getModel(URI.revive(additionalData.uri));
-            if (!textModel) {
-                return;
+        if (model.uri.scheme !== Schemas.sessionsChatInput) {
+            const currentContextIds = ( new Set(( target.attachments.map(attachment => attachment.id))));
+            const githubAttachments = getGitHubIssueOrPullRequestAttachments(textdata).filter(attachment => !( currentContextIds.has(attachment.id)));
+            if (githubAttachments.length) {
+                if (ranges.length !== 1) {
+                    return;
+                }
+                const announcement = githubAttachments.length === 1 ? ( localize(10031, "Attached {0} as context", githubAttachments[0].name)) : ( localize(10032, "Attached {0} GitHub links as context", githubAttachments.length));
+                const edit = createCustomPasteEdit(model, githubAttachments, Mimes.text, this.kind, ( localize(10033, "Paste GitHub Context")), this.pasteTargetService, {
+                    insertText: textdata,
+                    statusAnnouncement: announcement
+                });
+                return createEditSession(edit);
             }
-            const lineContent = textModel.getLineContent(start);
-            if (lineContent !== textdata) {
-                return;
+        }
+        let copiedContext;
+        if (editorData && additionalEditorData) {
+            try {
+                const metadata = JSON.parse(await editorData.asString());
+                const additionalData = JSON.parse(await additionalEditorData.asString());
+                const start = additionalData.range.startLineNumber;
+                const end = additionalData.range.endLineNumber;
+                let isWholeLine = true;
+                if (start === end) {
+                    const textModel = this.modelService.getModel(URI.revive(additionalData.uri));
+                    isWholeLine = !!textModel && start >= 1 && start <= textModel.getLineCount() && textModel.getLineContent(start) === textdata;
+                }
+                if (isWholeLine) {
+                    copiedContext = getCopiedContext(
+                        textdata,
+                        URI.revive(additionalData.uri),
+                        metadata.mode,
+                        additionalData.range
+                    );
+                }
+            } catch (error) {
+                this.logService.warn("Failed to read copied text metadata", error);
             }
         }
-        const copiedContext = getCopiedContext(
-            textdata,
-            URI.revive(additionalData.uri),
-            metadata.mode,
-            additionalData.range
-        );
-        if (token.isCancellationRequested || !copiedContext) {
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const hasRicherPaste = !!copiedContext || ( dataTransfer.has(CHAT_ATTACHMENT_MIME_TYPE)) || dataTransfer.matches("image/*");
+        const markdown = hasRicherPaste ? undefined : await getMeaningfulMarkdown(dataTransfer);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        const artifact = hasRicherPaste ? undefined : createPastedTextArtifact(textdata, target.attachments, {
+            content: markdown,
+            minLength: this.configurationService.getValue(ChatConfiguration.PasteAsAttachmentThreshold, {
+                resource: model.uri
+            })
+        });
+        if (artifact) {
+            if (ranges.length !== 1 || target.isTerminalCommandPaste(textdata, ranges[0])) {
+                return;
+            }
+            const pasteRange = ranges[0];
+            const referenceRange = ( new Range(
+                pasteRange.startLineNumber,
+                pasteRange.startColumn,
+                pasteRange.startLineNumber,
+                pasteRange.startColumn + artifact.referenceText.length
+            ));
+            const referenceOffset = model.getOffsetAt(referenceRange.getStartPosition());
+            const edit = createCustomPasteEdit(model, [{
+                ...artifact.attachment,
+                range: {
+                    start: referenceOffset,
+                    endExclusive: referenceOffset + artifact.referenceText.length
+                }
+            }], Mimes.text, this.kind, ( localize(10034, "Pasted Text Attachment")), this.pasteTargetService, {
+                inlineReference: {
+                    text: artifact.referenceText,
+                    range: referenceRange
+                },
+                announcement: ( localize(10035, "Attached pasted text as {0}", artifact.attachment.name))
+            });
+            return createEditSession(edit);
+        }
+        if (!copiedContext) {
             return;
         }
-        const currentContextIds = widget.attachmentModel.getAttachmentIDs();
+        const currentContextIds = ( new Set(( target.attachments.map(attachment => attachment.id))));
         if (( currentContextIds.has(copiedContext.id))) {
             return;
         }
-        const edit = createCustomPasteEdit(model, [copiedContext], Mimes.text, this.kind, ( localize(8342, "Pasted Code Attachment")), this.chatWidgetService);
+        const edit = createCustomPasteEdit(model, [copiedContext], Mimes.text, this.kind, ( localize(10036, "Pasted Code Attachment")), this.pasteTargetService);
         edit.yieldTo = [{
             kind: HierarchicalKind.Empty.append("text", "plain")
         }];
         return createEditSession(edit);
     }
 }
+function createPastedTextArtifact(text, existingAttachments, options) {
+    const trimmed = text.trim();
+    const minLength = options?.minLength ?? pastedTextArtifactDefaultMinLength;
+    if (!trimmed || trimmed.length < minLength) {
+        return undefined;
+    }
+    let index = 1;
+    let name;
+    do {
+        name = ( localize(10037, "Pasted text #{0}", index++));
+    } while (( existingAttachments.some(attachment => attachment.name === name)));
+    const content = options?.content;
+    const value = content ?? text;
+    const lineCount = countLines(value);
+    const pastedLines = lineCount === 1 ? ( localize(10038, "1 line")) : ( localize(10039, "{0} lines", lineCount));
+    const attachment = toPasteVariableEntry(name, value, {
+        language: content ? "markdown" : "plaintext",
+        fileName: name,
+        pastedLines,
+        _meta: {
+            [ChatPasteAttachmentMetadata.TextArtifact]: true
+        }
+    });
+    return {
+        attachment,
+        referenceText: `${chatVariableLeader}attachment:${name}`
+    };
+}
+function countLines(value) {
+    return value.split(/\r\n|\r|\n/).length;
+}
 function getCopiedContext(code, file, language, range) {
     const fileName = basename(file);
     const start = range.startLineNumber;
     const end = range.endLineNumber;
     const resultText = `Copied Selection of Code: \n\n\n From the file: ${fileName} From lines ${start} to ${end} \n \`\`\`${code}\`\`\``;
-    const pastedLines = start === end ? ( localize(8343, "1 line")) : ( localize(8344, "{0} lines", end + 1 - start));
+    const pastedLines = start === end ? ( localize(10040, "1 line")) : ( localize(10041, "{0} lines", end + 1 - start));
     return {
         kind: "paste",
         value: resultText,
@@ -361,27 +475,36 @@ function getCopiedContext(code, file, language, range) {
         }]
     };
 }
-function createCustomPasteEdit(model, context, handledMimeType, kind, title, chatWidgetService) {
-    const label = context.length === 1 ? context[0].name : ( localize(8345, "{0} and {1} more", context[0].name, context.length - 1));
+function createCustomPasteEdit(model, context, handledMimeType, kind, title, pasteTargetService, options) {
+    const label = context.length === 1 ? context[0].name : ( localize(10042, "{0} and {1} more", context[0].name, context.length - 1));
     const announceImageAttachment = context.length === 1 && isImageVariableEntry(context[0]);
+    const inlineReference = context.length === 1 ? options?.inlineReference : undefined;
+    const resolveTarget = operation => {
+        const target = pasteTargetService.getTarget(model.uri);
+        if (!target) {
+            throw ( new Error(`No chat paste target found for ${operation}`));
+        }
+        return target;
+    };
     const customEdit = {
         resource: model.uri,
         variable: context,
         undo: () => {
-            const widget = chatWidgetService.getWidgetByInputUri(model.uri);
-            if (!widget) {
-                throw ( new Error("No widget found for undo"));
-            }
-            widget.attachmentModel.delete(...( context.map(c => c.id)));
+            resolveTarget("undo").removeAttachments(( context.map(c => c.id)));
         },
         redo: () => {
-            const widget = chatWidgetService.getWidgetByInputUri(model.uri);
-            if (!widget) {
-                throw ( new Error("No widget found for redo"));
+            const target = resolveTarget("redo");
+            if (inlineReference) {
+                target.addInlineAttachment(context[0], inlineReference.text, inlineReference.range);
+            } else {
+                target.addAttachments(context);
             }
-            widget.attachmentModel.addContext(...context);
-            if (announceImageAttachment) {
-                alert(( localize(8346, "Attached image")));
+            if (options?.announcement) {
+                alert(options.announcement);
+            } else if (options?.statusAnnouncement) {
+                status(options.statusAnnouncement);
+            } else if (announceImageAttachment) {
+                alert(( localize(10043, "Attached image")));
             }
         },
         metadata: {
@@ -390,7 +513,7 @@ function createCustomPasteEdit(model, context, handledMimeType, kind, title, cha
         }
     };
     return {
-        insertText: "",
+        insertText: options?.inlineReference ? `${options.inlineReference.text} ` : options?.insertText ?? "",
         title,
         kind,
         handledMimeType,
@@ -489,12 +612,12 @@ async function resolveSymbolReference(
 }
 let PasteSymbolProvider = class PasteSymbolProvider {
     constructor(
-        chatWidgetService,
+        pasteTargetService,
         modelService,
         languageFeaturesService,
         outlineModelService
     ) {
-        this.chatWidgetService = chatWidgetService;
+        this.pasteTargetService = pasteTargetService;
         this.modelService = modelService;
         this.languageFeaturesService = languageFeaturesService;
         this.outlineModelService = outlineModelService;
@@ -504,7 +627,7 @@ let PasteSymbolProvider = class PasteSymbolProvider {
         this.pasteMimeTypes = [COPY_MIME_TYPES];
     }
     async provideDocumentPasteEdits(model, ranges, dataTransfer, _context, token) {
-        if (model.uri.scheme !== Schemas.vscodeChatInput) {
+        if (!isChatInputModel(model.uri)) {
             return;
         }
         const text = dataTransfer.get(Mimes.text);
@@ -524,8 +647,7 @@ let PasteSymbolProvider = class PasteSymbolProvider {
         }
         const sourceUri = URI.revive(additionalData.uri);
         const sourceRange = additionalData.range;
-        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-        if (!widget) {
+        if (!this.pasteTargetService.getTarget(model.uri)) {
             return;
         }
         const cached = await getCachedSymbolReference(sourceUri, sourceRange, pastedText);
@@ -565,15 +687,14 @@ let PasteSymbolProvider = class PasteSymbolProvider {
         };
         const edit = {
             insertText,
-            title: ( localize(8347, "Pasted Symbol Reference")),
+            title: ( localize(10044, "Pasted Symbol Reference")),
             kind: this.kind,
             handledMimeType: COPY_MIME_TYPES,
             additionalEdit: {
                 edits: [{
                     resource: model.uri,
                     redo: () => {
-                        const w = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                        w?.getContrib(ChatDynamicVariableModel.ID)?.addReference(dynamicRef);
+                        this.pasteTargetService.getTarget(model.uri)?.addInlineReference(dynamicRef);
                     },
                     undo: () => {}
                 }]
@@ -585,7 +706,7 @@ let PasteSymbolProvider = class PasteSymbolProvider {
         return createEditSession(edit);
     }
 };
-PasteSymbolProvider = ( __decorate([( __param(0, IChatWidgetService)), ( __param(1, IModelService)), ( __param(2, ILanguageFeaturesService)), ( __param(3, IOutlineModelService))], PasteSymbolProvider));
+PasteSymbolProvider = ( __decorate([( __param(0, IChatPasteTargetService)), ( __param(1, IModelService)), ( __param(2, ILanguageFeaturesService)), ( __param(3, IOutlineModelService))], PasteSymbolProvider));
 class PasteHtmlProvider {
     constructor() {
         this.kind = ( new HierarchicalKind("chat.paste.html"));
@@ -594,7 +715,7 @@ class PasteHtmlProvider {
         this.pasteMimeTypes = [Mimes.html];
     }
     async provideDocumentPasteEdits(model, _ranges, dataTransfer, context, token) {
-        if (model.uri.scheme !== Schemas.vscodeChatInput) {
+        if (!isChatInputModel(model.uri)) {
             return;
         }
         if (context.triggerKind !== DocumentPasteTriggerKind.Automatic) {
@@ -605,7 +726,7 @@ class PasteHtmlProvider {
         if (!htmlText || token.isCancellationRequested) {
             return;
         }
-        if (!/<(a|strong|b|em|i|h[1-6]|code|pre|ul|ol|li|blockquote|del|s|strike|img|hr)\b/i.test(htmlText)) {
+        if (!isMeaningfulHtml(htmlText)) {
             return;
         }
         const markdown = convertHtmlToMarkdown(htmlText);
@@ -614,7 +735,7 @@ class PasteHtmlProvider {
         }
         return createEditSession({
             insertText: markdown,
-            title: ( localize(8348, "Paste as Markdown")),
+            title: ( localize(10045, "Paste as Markdown")),
             kind: this.kind,
             handledMimeType: Mimes.html,
             yieldTo: [{
@@ -625,44 +746,45 @@ class PasteHtmlProvider {
         });
     }
 }
+async function getMeaningfulMarkdown(dataTransfer) {
+    const htmlText = await dataTransfer.get(Mimes.html)?.asString();
+    if (!htmlText || !isMeaningfulHtml(htmlText)) {
+        return undefined;
+    }
+    return convertHtmlToMarkdown(htmlText) || undefined;
+}
+function isMeaningfulHtml(value) {
+    return /<(a|strong|b|em|i|h[1-6]|code|pre|ul|ol|li|blockquote|del|s|strike|img|hr)\b/i.test(value);
+}
 let ChatPasteProvidersFeature = class ChatPasteProvidersFeature extends Disposable {
     constructor(
         instaService,
         languageFeaturesService,
-        chatWidgetService,
+        pasteTargetService,
         extensionService,
         fileService,
         modelService,
         environmentService,
-        logService
+        logService,
+        configurationService
     ) {
         super();
-        this._register(languageFeaturesService.documentPasteEditProvider.register({
-            scheme: Schemas.vscodeChatInput,
-            pattern: "*",
-            hasAccessToAllModels: true
-        }, instaService.createInstance(CopyAttachmentsProvider)));
-        this._register(languageFeaturesService.documentPasteEditProvider.register({
-            scheme: Schemas.vscodeChatInput,
-            pattern: "*",
-            hasAccessToAllModels: true
-        }, ( new PasteImageProvider(
-            chatWidgetService,
+        const chatInputProviders = [instaService.createInstance(CopyAttachmentsProvider), ( new PasteImageProvider(
+            pasteTargetService,
             extensionService,
             fileService,
             environmentService,
             logService
-        ))));
-        this._register(languageFeaturesService.documentPasteEditProvider.register({
-            scheme: Schemas.vscodeChatInput,
-            pattern: "*",
-            hasAccessToAllModels: true
-        }, ( new PasteTextProvider(chatWidgetService, modelService))));
-        this._register(languageFeaturesService.documentPasteEditProvider.register({
-            scheme: Schemas.vscodeChatInput,
-            pattern: "*",
-            hasAccessToAllModels: true
-        }, ( new PasteHtmlProvider())));
+        )), ( new PasteTextProvider(pasteTargetService, modelService, logService, configurationService)), ( new PasteHtmlProvider())];
+        for (const scheme of chatInputSchemes) {
+            for (const provider of chatInputProviders) {
+                this._register(languageFeaturesService.documentPasteEditProvider.register({
+                    scheme,
+                    pattern: "*",
+                    hasAccessToAllModels: true
+                }, provider));
+            }
+        }
         this._register(languageFeaturesService.documentPasteEditProvider.register({
             scheme: Schemas.vscodeChatInput,
             pattern: "*",
@@ -673,6 +795,6 @@ let ChatPasteProvidersFeature = class ChatPasteProvidersFeature extends Disposab
         );
     }
 };
-ChatPasteProvidersFeature = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILanguageFeaturesService)), ( __param(2, IChatWidgetService)), ( __param(3, IExtensionService)), ( __param(4, IFileService)), ( __param(5, IModelService)), ( __param(6, IEnvironmentService)), ( __param(7, ILogService))], ChatPasteProvidersFeature));
+ChatPasteProvidersFeature = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, ILanguageFeaturesService)), ( __param(2, IChatPasteTargetService)), ( __param(3, IExtensionService)), ( __param(4, IFileService)), ( __param(5, IModelService)), ( __param(6, IEnvironmentService)), ( __param(7, ILogService)), ( __param(8, IConfigurationService))], ChatPasteProvidersFeature));
 
-export { ChatPasteProvidersFeature, CopyTextProvider, PasteImageProvider, PasteTextProvider, isImage };
+export { CHAT_ATTACHMENT_MIME_TYPE, ChatPasteProvidersFeature, CopyTextProvider, PasteImageProvider, PasteTextProvider, createPastedTextArtifact, getGitHubIssueOrPullRequestAttachments, isImage, pastedTextArtifactDefaultMinLength };

package/vscode/src/vs/workbench/contrib/git/common/utils.d.ts

@@ -0,0 +1,8 @@
+import { GitRepositoryState } from "@codingame/monaco-vscode-extensions-service-override/vscode/vs/workbench/contrib/git/common/gitService";
+export interface IGitHubRemoteInfo {
+    readonly owner: string;
+    readonly repo: string;
+}
+export declare function hasGitHubRemotes(repositoryState: GitRepositoryState): boolean;
+export declare function getGitHubRemoteInfo(repositoryState: GitRepositoryState, supportedHosts?: readonly string[]): IGitHubRemoteInfo | undefined;
+export declare function getGitHubRepositoryFromRemoteUrl(remoteUrl: string, supportedHosts?: readonly string[]): IGitHubRemoteInfo | undefined;