@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.1

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

@@ -1,6 +1,8 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { ITerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
 import { DetachedProcessInfo } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/detachedTerminal';
 import { TERMINAL_BACKGROUND_COLOR } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry';
@@ -34,26 +36,41 @@ function getChatTerminalBackgroundColor(theme, contextKeyService, storedBackgrou
     const isInEditor = ChatContextKeys.inChatEditor.getValue(contextKeyService);
     return theme.getColor(isInEditor ? editorBackground : PANEL_BACKGROUND);
 }
-class DetachedTerminalMirror extends Disposable {
-    _setDetachedTerminal(detachedTerminal) {
-        this._detachedTerminal = detachedTerminal.then(terminal => this._register(terminal));
-    }
-    async _getTerminal() {
-        if (!this._detachedTerminal) {
-            throw ( new Error('Detached terminal not initialized'));
+function computeMaxBufferColumnWidth(buffer, cols) {
+    let maxWidth = 0;
+    for (let y = 0; y < buffer.length; y++) {
+        const line = buffer.getLine(y);
+        if (!line) {
+            continue;
+        }
+        const lineLength = Math.min(line.length, cols);
+        for (let x = lineLength - 1; x >= 0; x--) {
+            if (line.getCell(x)?.getChars()) {
+                maxWidth = Math.max(maxWidth, x + 1);
+                break;
+            }
         }
-        return this._detachedTerminal;
     }
-    async _attachToContainer(container) {
-        const terminal = await this._getTerminal();
-        container.classList.add('chat-terminal-output-terminal');
-        const needsAttach = this._attachedContainer !== container || container.firstChild === null;
-        if (needsAttach) {
-            terminal.attachToElement(container, { enableGpu: false });
-            this._attachedContainer = container;
+    return maxWidth;
+}
+function vtBoundaryMatches(newVT, oldVT, slicePoint, windowSize = 50) {
+    const start = Math.max(0, slicePoint - windowSize);
+    const end = slicePoint;
+    for (let i = start; i < end; i++) {
+        if (newVT.charCodeAt(i) !== oldVT.charCodeAt(i)) {
+            return false;
         }
-        return terminal;
     }
+    return true;
+}
+var ChatTerminalMirrorMetrics;
+(function(ChatTerminalMirrorMetrics) {
+    ChatTerminalMirrorMetrics[ChatTerminalMirrorMetrics["MirrorRowCount"] = 10] = "MirrorRowCount";
+    ChatTerminalMirrorMetrics[ChatTerminalMirrorMetrics["MirrorColCountFallback"] = 80] = "MirrorColCountFallback";
+    ChatTerminalMirrorMetrics[ChatTerminalMirrorMetrics["MaxLinesForColumnWidthComputation"] = 100] = "MaxLinesForColumnWidthComputation";
+})(ChatTerminalMirrorMetrics || (ChatTerminalMirrorMetrics = {}));
+function computeOutputLineCount(startLine, endLine) {
+    return Math.max(endLine - startLine, 0);
 }
 async function getCommandOutputSnapshot(xtermTerminal, command, log) {
     const executedMarker = command.executedMarker;
@@ -64,11 +81,7 @@ async function getCommandOutputSnapshot(xtermTerminal, command, log) {
     if (!executedMarker || executedMarker.isDisposed) {
         const raw = xtermTerminal.raw;
         const buffer = raw.buffer.active;
-        const offsets = [
-            -(buffer.baseY + buffer.cursorY),
-            -buffer.baseY,
-            0
-        ];
+        const offsets = [-(buffer.baseY + buffer.cursorY), -buffer.baseY, 0];
         let startMarker;
         for (const offset of offsets) {
             startMarker = raw.registerMarker(offset);
@@ -77,85 +90,383 @@ async function getCommandOutputSnapshot(xtermTerminal, command, log) {
             }
         }
         if (!startMarker || startMarker.isDisposed) {
-            return { text: '', lineCount: 0 };
+            return {
+                text: "",
+                lineCount: 0
+            };
         }
         const startLine = startMarker.line;
         let text;
         try {
             text = await xtermTerminal.getRangeAsVT(startMarker, endMarker, true);
-        }
-        catch (error) {
-            log?.('fallback', error);
+        } catch (error) {
+            log?.("fallback", error);
             return undefined;
-        }
-        finally {
+        } finally {
             startMarker.dispose();
         }
         if (!text) {
-            return { text: '', lineCount: 0 };
+            return {
+                text: "",
+                lineCount: 0
+            };
         }
-        const endLine = endMarker.line - 1;
-        const lineCount = Math.max(endLine - startLine + 1, 0);
-        return { text, lineCount };
+        const endLine = endMarker.line;
+        const lineCount = computeOutputLineCount(startLine, endLine);
+        return {
+            text,
+            lineCount
+        };
     }
     const startLine = executedMarker.line;
-    const endLine = endMarker.line - 1;
-    const lineCount = Math.max(endLine - startLine + 1, 0);
+    const endLine = endMarker.line;
+    const lineCount = computeOutputLineCount(startLine, endLine);
     let text;
     try {
         text = await xtermTerminal.getRangeAsVT(executedMarker, endMarker, true);
-    }
-    catch (error) {
-        log?.('primary', error);
+    } catch (error) {
+        log?.("primary", error);
         return undefined;
     }
     if (!text) {
-        return { text: '', lineCount: 0 };
+        return {
+            text: "",
+            lineCount: 0
+        };
     }
-    return { text, lineCount };
+    return {
+        text,
+        lineCount
+    };
 }
-let DetachedTerminalCommandMirror = class DetachedTerminalCommandMirror extends DetachedTerminalMirror {
+let DetachedTerminalCommandMirror = class DetachedTerminalCommandMirror extends Disposable {
     constructor(_xtermTerminal, _command, _terminalService, _contextKeyService) {
         super();
         this._xtermTerminal = _xtermTerminal;
         this._command = _command;
         this._terminalService = _terminalService;
         this._contextKeyService = _contextKeyService;
-        const processInfo = this._register(( new DetachedProcessInfo({ initialCwd: '' })));
-        this._setDetachedTerminal(this._terminalService.createDetachedTerminal({
-            cols: this._xtermTerminal.raw.cols,
-            rows: 10,
-            readonly: true,
-            processInfo,
-            disableOverviewRuler: true,
-            colorProvider: {
-                getBackgroundColor: theme => getChatTerminalBackgroundColor(theme, this._contextKeyService),
-            },
+        this._streamingDisposables = this._register(( new DisposableStore()));
+        this._onDidUpdateEmitter = this._register(( new Emitter()));
+        this.onDidUpdate = this._onDidUpdateEmitter.event;
+        this._onDidInputEmitter = this._register(( new Emitter()));
+        this.onDidInput = this._onDidInputEmitter.event;
+        this._lastVT = "";
+        this._lineCount = 0;
+        this._maxColumnWidth = 0;
+        this._dirtyScheduled = false;
+        this._isStreaming = false;
+        this._register(toDisposable(() => {
+            this._stopStreaming();
         }));
     }
     async attach(container) {
-        await this._attachToContainer(container);
+        if (this._store.isDisposed) {
+            return;
+        }
+        let terminal;
+        try {
+            terminal = await this._getOrCreateTerminal();
+        } catch (error) {
+            if (error instanceof CancellationError) {
+                return;
+            }
+            throw error;
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
+        if (this._attachedContainer !== container) {
+            container.classList.add("chat-terminal-output-terminal");
+            terminal.attachToElement(container, {
+                enableGpu: false
+            });
+            this._attachedContainer = container;
+        }
     }
     async renderCommand() {
-        const vt = await getCommandOutputSnapshot(this._xtermTerminal, this._command);
+        if (this._store.isDisposed) {
+            return undefined;
+        }
+        let detached;
+        try {
+            detached = await this._getOrCreateTerminal();
+        } catch (error) {
+            if (error instanceof CancellationError) {
+                return undefined;
+            }
+            throw error;
+        }
+        if (this._store.isDisposed) {
+            return undefined;
+        }
+        let vt;
+        try {
+            vt = await this._getCommandOutputAsVT(this._xtermTerminal);
+        } catch {}
         if (!vt) {
             return undefined;
         }
-        if (!vt.text) {
-            return { lineCount: 0 };
+        if (this._store.isDisposed) {
+            return undefined;
+        }
+        await ( new Promise(resolve => {
+            const canAppend = !!this._lastVT && vt.text.length >= this._lastVT.length && this._vtBoundaryMatches(vt.text, this._lastVT.length);
+            if (!canAppend) {
+                if (this._lastVT) {
+                    detached.xterm.reset();
+                }
+                if (vt.text) {
+                    detached.xterm.write(vt.text, resolve);
+                } else {
+                    resolve();
+                }
+            } else {
+                const appended = vt.text.slice(this._lastVT.length);
+                if (appended) {
+                    detached.xterm.write(appended, resolve);
+                } else {
+                    resolve();
+                }
+            }
+        }));
+        this._lastVT = vt.text;
+        const sourceRaw = this._xtermTerminal.raw;
+        if (sourceRaw) {
+            this._sourceRaw = sourceRaw;
+            this._lastUpToDateCursorY = this._getAbsoluteCursorY(sourceRaw);
+            if (!this._isStreaming && (!this._command.endMarker || this._command.endMarker.isDisposed)) {
+                this._startStreaming(sourceRaw);
+            }
+        }
+        this._lineCount = this._getRenderedLineCount();
+        const commandFinished = this._command.endMarker && !this._command.endMarker.isDisposed;
+        if (commandFinished && this._lineCount <= ChatTerminalMirrorMetrics.MaxLinesForColumnWidthComputation) {
+            this._maxColumnWidth = this._computeMaxColumnWidth();
+        }
+        return {
+            lineCount: this._lineCount,
+            maxColumnWidth: this._maxColumnWidth
+        };
+    }
+    async _getCommandOutputAsVT(source) {
+        if (this._store.isDisposed) {
+            return undefined;
+        }
+        const executedMarker = this._command.executedMarker ?? this._command.commandExecutedMarker;
+        if (!executedMarker) {
+            return undefined;
+        }
+        const endMarker = this._command.endMarker;
+        const text = await source.getRangeAsVT(executedMarker, endMarker, endMarker?.line !== executedMarker.line);
+        if (this._store.isDisposed) {
+            return undefined;
+        }
+        if (!text) {
+            return {
+                text: ""
+            };
+        }
+        return {
+            text
+        };
+    }
+    _getRenderedLineCount() {
+        const endMarker = this._command.endMarker;
+        if (this._command.executedMarker && endMarker && !endMarker.isDisposed) {
+            const startLine = this._command.executedMarker.line;
+            const endLine = endMarker.line;
+            return computeOutputLineCount(startLine, endLine);
+        }
+        const executedMarker = this._command.executedMarker ?? this._command.commandExecutedMarker;
+        if (executedMarker && this._sourceRaw) {
+            const buffer = this._sourceRaw.buffer.active;
+            const currentLine = buffer.baseY + buffer.cursorY;
+            return computeOutputLineCount(executedMarker.line, currentLine);
+        }
+        return this._lineCount;
+    }
+    _computeMaxColumnWidth() {
+        const detached = this._detachedTerminal;
+        if (!detached) {
+            return 0;
+        }
+        return computeMaxBufferColumnWidth(detached.xterm.buffer.active, detached.xterm.cols);
+    }
+    async _getOrCreateTerminal() {
+        if (this._detachedTerminal) {
+            return this._detachedTerminal;
+        }
+        if (this._detachedTerminalPromise) {
+            return this._detachedTerminalPromise;
         }
-        const detached = await this._getTerminal();
+        if (this._store.isDisposed) {
+            throw ( new CancellationError());
+        }
+        const createPromise = (async () => {
+            const colorProvider = {
+                getBackgroundColor: theme => getChatTerminalBackgroundColor(theme, this._contextKeyService)
+            };
+            const processInfo = ( new DetachedProcessInfo({
+                initialCwd: ""
+            }));
+            const detached = await this._terminalService.createDetachedTerminal({
+                cols: this._xtermTerminal.raw.cols ?? ChatTerminalMirrorMetrics.MirrorColCountFallback,
+                rows: ChatTerminalMirrorMetrics.MirrorRowCount,
+                readonly: false,
+                processInfo,
+                disableOverviewRuler: true,
+                colorProvider
+            });
+            if (this._store.isDisposed) {
+                processInfo.dispose();
+                detached.dispose();
+                throw ( new CancellationError());
+            }
+            this._detachedTerminal = detached;
+            this._register(processInfo);
+            this._register(detached);
+            this._register(detached.onData(data => this._onDidInputEmitter.fire(data)));
+            return detached;
+        })();
+        this._detachedTerminalPromise = createPromise;
+        return createPromise;
+    }
+    _startStreaming(raw) {
+        if (this._store.isDisposed || this._isStreaming) {
+            return;
+        }
+        this._isStreaming = true;
+        this._streamingDisposables.add(
+            Event.any(raw.onCursorMove, raw.onLineFeed, raw.onWriteParsed)(() => this._handleCursorEvent())
+        );
+        this._streamingDisposables.add(raw.onData(() => this._handleCursorEvent()));
+    }
+    _stopStreaming() {
+        if (!this._isStreaming) {
+            return;
+        }
+        this._streamingDisposables.clear();
+        this._isStreaming = false;
+        this._lowestDirtyCursorY = undefined;
+        this._sourceRaw = undefined;
+    }
+    _handleCursorEvent() {
+        if (this._store.isDisposed || !this._sourceRaw) {
+            return;
+        }
+        const cursorY = this._getAbsoluteCursorY(this._sourceRaw);
+        this._lowestDirtyCursorY = this._lowestDirtyCursorY === undefined ? cursorY : Math.min(this._lowestDirtyCursorY, cursorY);
+        this._scheduleFlush();
+    }
+    _scheduleFlush() {
+        if (this._dirtyScheduled || this._store.isDisposed) {
+            return;
+        }
+        this._dirtyScheduled = true;
+        queueMicrotask(() => {
+            this._dirtyScheduled = false;
+            if (this._store.isDisposed) {
+                return;
+            }
+            this._flushDirtyRange();
+        });
+    }
+    _flushDirtyRange() {
+        if (this._store.isDisposed || this._flushPromise) {
+            return;
+        }
+        this._flushPromise = this._doFlushDirtyRange().finally(() => {
+            this._flushPromise = undefined;
+        });
+    }
+    async _doFlushDirtyRange() {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const sourceRaw = this._xtermTerminal.raw;
+        let detached = this._detachedTerminal;
+        if (!detached) {
+            try {
+                detached = await this._getOrCreateTerminal();
+            } catch (error) {
+                if (error instanceof CancellationError) {
+                    return;
+                }
+                throw error;
+            }
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
+        const detachedRaw = detached?.xterm;
+        if (!sourceRaw || !detachedRaw) {
+            return;
+        }
+        this._sourceRaw = sourceRaw;
+        const currentCursor = this._getAbsoluteCursorY(sourceRaw);
+        const previousCursor = this._lastUpToDateCursorY ?? currentCursor;
+        const startCandidate = this._lowestDirtyCursorY ?? currentCursor;
+        this._lowestDirtyCursorY = undefined;
+        const startLine = Math.min(previousCursor, startCandidate);
+        const vt = await this._getCommandOutputAsVT(this._xtermTerminal);
+        if (!vt) {
+            return;
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
+        if (vt.text === this._lastVT) {
+            this._lastUpToDateCursorY = currentCursor;
+            if (this._command.endMarker && !this._command.endMarker.isDisposed) {
+                this._stopStreaming();
+            }
+            return;
+        }
+        const canAppend = !!this._lastVT && startLine >= previousCursor && vt.text.length >= this._lastVT.length && this._vtBoundaryMatches(vt.text, this._lastVT.length);
         await ( new Promise(resolve => {
-            detached.xterm.write(vt.text, () => resolve());
+            if (!canAppend) {
+                if (this._lastVT) {
+                    detachedRaw.reset();
+                }
+                if (vt.text) {
+                    detachedRaw.write(vt.text, resolve);
+                } else {
+                    resolve();
+                }
+            } else {
+                const appended = vt.text.slice(this._lastVT.length);
+                if (appended) {
+                    detachedRaw.write(appended, resolve);
+                } else {
+                    resolve();
+                }
+            }
         }));
-        return { lineCount: vt.lineCount };
+        this._lastVT = vt.text;
+        this._lineCount = this._getRenderedLineCount();
+        this._lastUpToDateCursorY = currentCursor;
+        const commandFinished = this._command.endMarker && !this._command.endMarker.isDisposed;
+        if (commandFinished) {
+            if (this._lineCount <= ChatTerminalMirrorMetrics.MaxLinesForColumnWidthComputation) {
+                this._maxColumnWidth = this._computeMaxColumnWidth();
+            }
+            this._stopStreaming();
+        }
+        this._onDidUpdateEmitter.fire({
+            lineCount: this._lineCount,
+            maxColumnWidth: this._maxColumnWidth
+        });
+    }
+    _getAbsoluteCursorY(raw) {
+        return raw.buffer.active.baseY + raw.buffer.active.cursorY;
+    }
+    _vtBoundaryMatches(newVT, slicePoint) {
+        return vtBoundaryMatches(newVT, this._lastVT, slicePoint);
     }
 };
-DetachedTerminalCommandMirror = ( __decorate([
-    ( __param(2, ITerminalService)),
-    ( __param(3, IContextKeyService))
-], DetachedTerminalCommandMirror));
-let DetachedTerminalSnapshotMirror = class DetachedTerminalSnapshotMirror extends DetachedTerminalMirror {
+DetachedTerminalCommandMirror = ( __decorate([( __param(2, ITerminalService)), ( __param(3, IContextKeyService))], DetachedTerminalCommandMirror));
+let DetachedTerminalSnapshotMirror = class DetachedTerminalSnapshotMirror extends Disposable {
     constructor(output, _getTheme, _terminalService, _contextKeyService) {
         super();
         this._getTheme = _getTheme;
@@ -163,10 +474,12 @@ let DetachedTerminalSnapshotMirror = class DetachedTerminalSnapshotMirror extend
         this._contextKeyService = _contextKeyService;
         this._dirty = true;
         this._output = output;
-        const processInfo = this._register(( new DetachedProcessInfo({ initialCwd: '' })));
-        this._setDetachedTerminal(this._terminalService.createDetachedTerminal({
-            cols: 80,
-            rows: 10,
+        const processInfo = this._register(( new DetachedProcessInfo({
+            initialCwd: ""
+        })));
+        this._detachedTerminal = this._terminalService.createDetachedTerminal({
+            cols: ChatTerminalMirrorMetrics.MirrorColCountFallback,
+            rows: ChatTerminalMirrorMetrics.MirrorRowCount,
             readonly: true,
             processInfo,
             disableOverviewRuler: true,
@@ -176,14 +489,37 @@ let DetachedTerminalSnapshotMirror = class DetachedTerminalSnapshotMirror extend
                     return getChatTerminalBackgroundColor(theme, this._contextKeyService, storedBackground);
                 }
             }
-        }));
+        }).then(terminal => {
+            if (this._store.isDisposed) {
+                terminal.dispose();
+                return terminal;
+            }
+            return this._register(terminal);
+        });
+    }
+    async _getTerminal() {
+        if (!this._detachedTerminal) {
+            throw ( new Error("Detached terminal not initialized"));
+        }
+        return this._detachedTerminal;
     }
     setOutput(output) {
         this._output = output;
         this._dirty = true;
     }
     async attach(container) {
-        await this._attachToContainer(container);
+        const terminal = await this._getTerminal();
+        if (this._store.isDisposed) {
+            return;
+        }
+        container.classList.add("chat-terminal-output-terminal");
+        const needsAttach = this._attachedContainer !== container || container.firstChild === null;
+        if (needsAttach) {
+            terminal.attachToElement(container, {
+                enableGpu: false
+            });
+            this._attachedContainer = container;
+        }
         this._container = container;
         this._applyTheme(container);
     }
@@ -193,38 +529,63 @@ let DetachedTerminalSnapshotMirror = class DetachedTerminalSnapshotMirror extend
             return undefined;
         }
         if (!this._dirty) {
-            return { lineCount: this._lastRenderedLineCount ?? output.lineCount };
+            return {
+                lineCount: this._lastRenderedLineCount ?? output.lineCount,
+                maxColumnWidth: this._lastRenderedMaxColumnWidth
+            };
         }
         const terminal = await this._getTerminal();
+        if (this._store.isDisposed) {
+            return undefined;
+        }
         if (this._container) {
             this._applyTheme(this._container);
         }
-        const text = output.text ?? '';
+        const text = output.text ?? "";
         const lineCount = output.lineCount ?? this._estimateLineCount(text);
         if (!text) {
             this._dirty = false;
             this._lastRenderedLineCount = lineCount;
-            return { lineCount: 0 };
+            this._lastRenderedMaxColumnWidth = 0;
+            return {
+                lineCount: 0,
+                maxColumnWidth: 0
+            };
         }
         await ( new Promise(resolve => terminal.xterm.write(text, resolve)));
+        if (this._store.isDisposed) {
+            return undefined;
+        }
         this._dirty = false;
         this._lastRenderedLineCount = lineCount;
-        return { lineCount };
+        if (this._shouldComputeMaxColumnWidth(lineCount)) {
+            this._lastRenderedMaxColumnWidth = this._computeMaxColumnWidth(terminal);
+        }
+        return {
+            lineCount,
+            maxColumnWidth: this._lastRenderedMaxColumnWidth
+        };
+    }
+    _computeMaxColumnWidth(terminal) {
+        return computeMaxBufferColumnWidth(terminal.xterm.buffer.active, terminal.xterm.cols);
     }
     _estimateLineCount(text) {
         if (!text) {
             return 0;
         }
-        const sanitized = text.replace(/\r/g, '');
-        const segments = sanitized.split('\n');
-        const count = sanitized.endsWith('\n') ? segments.length - 1 : segments.length;
+        const sanitized = text.replace(/\r/g, "");
+        const segments = sanitized.split("\n");
+        const count = sanitized.endsWith("\n") ? segments.length - 1 : segments.length;
         return Math.max(count, 1);
     }
+    _shouldComputeMaxColumnWidth(lineCount) {
+        return lineCount <= ChatTerminalMirrorMetrics.MaxLinesForColumnWidthComputation;
+    }
     _applyTheme(container) {
         const theme = this._getTheme();
         if (!theme) {
-            container.style.removeProperty('background-color');
-            container.style.removeProperty('color');
+            container.style.removeProperty("background-color");
+            container.style.removeProperty("color");
             return;
         }
         if (theme.background) {
@@ -235,9 +596,6 @@ let DetachedTerminalSnapshotMirror = class DetachedTerminalSnapshotMirror extend
         }
     }
 };
-DetachedTerminalSnapshotMirror = ( __decorate([
-    ( __param(2, ITerminalService)),
-    ( __param(3, IContextKeyService))
-], DetachedTerminalSnapshotMirror));
+DetachedTerminalSnapshotMirror = ( __decorate([( __param(2, ITerminalService)), ( __param(3, IContextKeyService))], DetachedTerminalSnapshotMirror));
 
-export { DetachedTerminalCommandMirror, DetachedTerminalSnapshotMirror, getCommandOutputSnapshot };
+export { DetachedTerminalCommandMirror, DetachedTerminalSnapshotMirror, computeMaxBufferColumnWidth, getCommandOutputSnapshot, vtBoundaryMatches };

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

@@ -1,34 +0,0 @@
-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 { ResourceSet } from "@codingame/monaco-vscode-api/vscode/vs/base/common/map";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
-import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service";
-import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
-export declare class ChatRelatedFilesContribution extends Disposable implements IWorkbenchContribution {
-    private readonly chatEditingService;
-    private readonly chatWidgetService;
-    static readonly ID = "chat.relatedFilesWorkingSet";
-    private readonly chatEditingSessionDisposables;
-    private _currentRelatedFilesRetrievalOperation;
-    constructor(chatEditingService: IChatEditingService, chatWidgetService: IChatWidgetService);
-    private _updateRelatedFileSuggestions;
-    private _handleNewEditingSession;
-    dispose(): void;
-}
-export interface IChatRelatedFile {
-    uri: URI;
-    description: string;
-}
-export declare class ChatRelatedFiles extends Disposable {
-    private readonly _onDidChange;
-    readonly onDidChange: Event<void>;
-    private _removedFiles;
-    get removedFiles(): ResourceSet;
-    private _value;
-    get value(): IChatRelatedFile[];
-    set value(value: IChatRelatedFile[]);
-    remove(uri: URI): void;
-    clearRemovedFiles(): void;
-    clear(): void;
-}